asciigoat's INI parser
https://asciigoat.org/ini
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
145 lines
3.5 KiB
145 lines
3.5 KiB
1 year ago
|
package ini
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"log"
|
||
|
|
||
|
"asciigoat.org/core/lexer"
|
||
|
"asciigoat.org/ini/parser"
|
||
|
)
|
||
|
|
||
|
type token struct {
|
||
|
pos lexer.Position
|
||
|
typ parser.TokenType
|
||
|
value string
|
||
|
}
|
||
|
|
||
|
func (t token) String() string {
|
||
|
return fmt.Sprintf("%s %s: %q", t.pos, t.typ, t.value)
|
||
|
}
|
||
|
|
||
|
// queueValue extracts the value of element on the queue if the type matches.
|
||
|
func (dec *Decoder) queueValue(idx int, typ parser.TokenType) (string, bool) {
|
||
|
switch {
|
||
|
case idx < 0 || idx >= len(dec.queue):
|
||
|
// out of range
|
||
|
return "", false
|
||
|
case dec.queue[idx].typ != typ:
|
||
|
// wrong type
|
||
|
return "", false
|
||
|
default:
|
||
|
// match
|
||
|
return dec.queue[idx].value, true
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// queueReset removes all tokens from the queue
|
||
|
func (dec *Decoder) queueReset() {
|
||
|
dec.queue = dec.queue[:0]
|
||
|
}
|
||
|
|
||
|
// queueType tells if the specified element on the queue is of the required type.
|
||
|
func (dec *Decoder) queueType(idx int, typ parser.TokenType) bool {
|
||
|
_, ok := dec.queueValue(idx, typ)
|
||
|
return ok
|
||
|
}
|
||
|
|
||
|
// queueDepth confirms the current depth of the queue
|
||
|
func (dec *Decoder) queueDepth(depth int) bool {
|
||
|
return len(dec.queue) == depth
|
||
|
}
|
||
|
|
||
|
// queueDepthType confirms the current depth of the queue and the type of the last
|
||
|
// element.
|
||
|
func (dec *Decoder) queueDepthType(depth int, typ parser.TokenType) bool {
|
||
|
if dec.queueDepth(depth) {
|
||
|
return dec.queueType(depth-1, typ)
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// typeOK tells if a token of the specified type is acceptable
|
||
|
// at this time.
|
||
|
func (dec *Decoder) typeOK(typ parser.TokenType) bool {
|
||
|
switch typ {
|
||
|
case parser.TokenSectionStart:
|
||
|
return dec.queueDepth(0)
|
||
|
case parser.TokenSectionName:
|
||
|
return dec.queueDepthType(1, parser.TokenSectionStart)
|
||
|
case parser.TokenSectionSubname:
|
||
|
return dec.queueDepthType(2, parser.TokenSectionName)
|
||
|
case parser.TokenSectionEnd:
|
||
|
return dec.queueType(1, parser.TokenSectionName)
|
||
|
case parser.TokenFieldKey:
|
||
|
return dec.queueDepth(0)
|
||
|
case parser.TokenFieldValue:
|
||
|
return dec.queueDepthType(1, parser.TokenFieldKey)
|
||
|
case parser.TokenComment:
|
||
|
panic("unreachable")
|
||
|
default:
|
||
|
return false
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// execute is called after each acceptable token is appended to the queue
|
||
|
func (dec *Decoder) execute() error {
|
||
|
if l := len(dec.queue); l > 0 {
|
||
|
// based on the type of the last element
|
||
|
switch dec.queue[l-1].typ {
|
||
|
case parser.TokenSectionEnd:
|
||
|
name1, _ := dec.queueValue(1, parser.TokenSectionName)
|
||
|
name2, ok2 := dec.queueValue(2, parser.TokenSectionSubname)
|
||
|
defer dec.queueReset()
|
||
|
|
||
|
return dec.executeSection(name1, name2, ok2)
|
||
|
case parser.TokenFieldValue:
|
||
|
key, _ := dec.queueValue(0, parser.TokenFieldKey)
|
||
|
value, _ := dec.queueValue(1, parser.TokenFieldValue)
|
||
|
defer dec.queueReset()
|
||
|
|
||
|
return dec.executeField(key, value)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// revive:disable:flag-parameter
|
||
|
|
||
|
func (*Decoder) executeSection(key, id string, hasID bool) error {
|
||
|
// revive:enable:flag-parameter
|
||
|
|
||
|
if hasID {
|
||
|
log.Printf("%s: %s%s[%q]: %q", "ini", "", "section", key, id)
|
||
|
} else {
|
||
|
log.Printf("%s: %s%s[%q]", "ini", "", "section", key)
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (*Decoder) executeField(key, value string) error {
|
||
|
log.Printf("%s: %s%s[%q]: %q", "ini", " ", "field", key, value)
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// parserOnToken is the callback from the parser
|
||
|
func (dec *Decoder) parserOnToken(pos lexer.Position, typ parser.TokenType, value string) error {
|
||
|
var err error
|
||
|
|
||
|
t := &token{pos, typ, value}
|
||
|
switch {
|
||
|
case typ == parser.TokenComment:
|
||
|
// ignore comments
|
||
|
case dec.typeOK(typ):
|
||
|
// acceptable token
|
||
|
dec.queue = append(dec.queue, t)
|
||
|
err = dec.execute()
|
||
|
default:
|
||
|
// unacceptable
|
||
|
err = dec.newErrInvalidToken(t)
|
||
|
}
|
||
|
|
||
|
return err
|
||
|
}
|