Compare commits

...

9 Commits

Author SHA1 Message Date
Alejandro Mery 3bf20948c0 parser: Unescaped [WIP] 1 year ago
Alejandro Mery 0dd29272e9 build-sys: use local darvaza.org/core [DO-NOT-MERGE] 1 year ago
Alejandro Mery 7fab1a799a build-sys: use local asciigoat.org/core [DO-NOT-MERGE] 1 year ago
Alejandro Mery 16dfde1503 vscode: add Subname to the dictionary 1 year ago
Alejandro Mery 41d7c6e04d vscode: add unescapes to the dictionary 1 year ago
Alejandro Mery 48adaeb8a8 vscode: add asciigoat to the dictionary 1 year ago
Alejandro Mery 99ca8d0b3b Merge branch 'pr-amery-basic' into next-amery 1 year ago
Alejandro Mery fa9a7b4735 basic: rename and document queue related methods 1 year ago
Alejandro Mery cfd4a94559 basic: call executeFinal() when OnToken() fails 1 year ago
  1. 7
      .vscode/settings.json
  2. 51
      basic/token.go
  3. 5
      go.mod
  4. 2
      go.sum
  5. 19
      parser/error.go
  6. 80
      parser/text_quoted.go

7
.vscode/settings.json vendored

@ -0,0 +1,7 @@
{
"cSpell.words": [
"asciigoat",
"Subname",
"unescapes"
]
}

51
basic/token.go

@ -32,21 +32,21 @@ func (dec *decoder) executeFinal() {
func (dec *decoder) execute(typ parser.TokenType) {
switch typ {
case parser.TokenSectionEnd:
name1, ok1 := dec.getValue(1, parser.TokenSectionName)
name1, ok1 := dec.queueValue(1, parser.TokenSectionName)
if ok1 {
name2, ok2 := dec.getValue(2, parser.TokenSectionSubname)
name2, ok2 := dec.queueValue(2, parser.TokenSectionSubname)
dec.addSection(name1, name2, ok2)
}
dec.reset()
dec.queueReset()
case parser.TokenFieldValue:
key, _ := dec.getValue(0, parser.TokenFieldKey)
value, _ := dec.getValue(1, parser.TokenFieldValue)
key, _ := dec.queueValue(0, parser.TokenFieldKey)
value, _ := dec.queueValue(1, parser.TokenFieldValue)
dec.addField(key, value)
dec.reset()
dec.queueReset()
}
}
@ -82,7 +82,8 @@ func (dec *decoder) addField(key, value string) {
}
}
func (dec *decoder) getValue(idx int, typ parser.TokenType) (string, bool) {
// 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
@ -95,40 +96,48 @@ func (dec *decoder) getValue(idx int, typ parser.TokenType) (string, bool) {
}
}
func (dec *decoder) reset() {
// queueReset removes all tokens from the queue
func (dec *decoder) queueReset() {
dec.queue = dec.queue[:0]
}
func (dec *decoder) depth(depth int) bool {
// queueDepth confirms the current depth of the queue
func (dec *decoder) queueDepth(depth int) bool {
return len(dec.queue) == depth
}
func (dec *decoder) depthAfter(depth int, typ parser.TokenType) bool {
_, ok := dec.getValue(depth-1, typ)
if ok {
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
}
// 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
}
func (dec *decoder) typeOK(typ parser.TokenType) bool {
switch typ {
case parser.TokenSectionStart, parser.TokenFieldKey:
// first token only
return dec.depth(0)
return dec.queueDepth(0)
case parser.TokenSectionName:
// right after TokenSectionStart
return dec.depthAfter(1, parser.TokenSectionStart)
return dec.queueDepthType(1, parser.TokenSectionStart)
case parser.TokenSectionSubname:
// right after TokenSectionName
return dec.depthAfter(2, parser.TokenSectionName)
return dec.queueDepthType(2, parser.TokenSectionName)
case parser.TokenSectionEnd:
// only on a section with name
_, ok := dec.getValue(1, parser.TokenSectionName)
return ok
return dec.queueType(1, parser.TokenSectionName)
case parser.TokenFieldValue:
// right after a TokenFieldKey
return dec.depthAfter(1, parser.TokenFieldKey)
return dec.queueDepthType(1, parser.TokenFieldKey)
default:
// never
return false
@ -149,6 +158,8 @@ func (dec *decoder) OnToken(pos lexer.Position, typ parser.TokenType, value stri
return nil
default:
// unacceptable
return newErrInvalidToken(t)
err := newErrInvalidToken(t)
dec.executeFinal()
return err
}
}

5
go.mod

@ -2,6 +2,11 @@ module asciigoat.org/ini
go 1.19
replace (
asciigoat.org/core => ../core
darvaza.org/core => ../../darvaza.org/core
)
require (
asciigoat.org/core v0.3.9
github.com/mgechev/revive v1.3.3

2
go.sum

@ -1,5 +1,3 @@
asciigoat.org/core v0.3.9 h1:hgDDz4ecm3ZvehX++m8A/IzAt+B5oDPiRtxatzfUHPQ=
asciigoat.org/core v0.3.9/go.mod h1:CAaHwyw8MpAq4a1MYtN2dxJrsK+hmIdW50OndaQZYPI=
github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
github.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=

19
parser/error.go

@ -35,9 +35,28 @@ func NewErrIncompleteQuotedString(p *TextParser) *lexer.Error {
return newErrIncomplete(p, "incomplete quoted string")
}
// NewErrIncompleteEscaped returns a [lexer.Error]
// indicating the text being parsed wasn't correctly
// terminated
func NewErrIncompleteEscaped(p *TextParser) *lexer.Error {
return newErrIncomplete(p, "incomplete escaped string")
}
func newErrIncomplete(p *TextParser, hint string) *lexer.Error {
pos, s := p.Emit()
pos.Add(GetPositionalLength(s))
return NewError(pos, s, hint, fs.ErrInvalid)
}
// NewErrInvalidEscapeSequence returns a [lexer.Error] indicating
// the specified sequence, at the end of the accepted buffer,
// is invalid
func NewErrInvalidEscapeSequence(p *TextParser, seq string) *lexer.Error {
pos, s := p.Position(), p.String()
s = s[:len(s)-len(seq)]
pos.Add(GetPositionalLength(s))
return NewError(pos, seq, "invalid escape character", fs.ErrInvalid)
}

80
parser/text_quoted.go

@ -33,22 +33,34 @@ func (p *TextParser) AcceptQuotedString() (string, bool, error) {
}
func lexQuotedString(p *TextParser) (string, *lexer.Error) {
s, ok, err := lexQuotedStringNoEscape(p)
switch {
case err != nil:
return "", err
case ok:
return s, nil
default:
// escape character detected
return lexQuotedStringEscaped(p)
}
}
func lexQuotedStringNoEscape(p *TextParser) (string, bool, *lexer.Error) {
for {
r, _, err := p.ReadRune()
switch {
case err != nil:
// incomplete
return "", NewErrIncompleteQuotedString(p)
return "", false, NewErrIncompleteQuotedString(p)
case r == RuneQuotes:
// end, remove quotes and process escaped characters
return lexReturnUnescapedQuotedString(p)
// end, just remove the quotes
s := p.String()
l := len(s)
return s[1 : l-1], true, nil
case r == RuneEscape:
// escaped, take another
_, _, err := p.ReadRune()
if err != nil {
// incomplete
return "", NewErrIncompleteQuotedString(p)
}
// things just got complicated...
p.UnreadRune()
return "", false, nil
case IsNewLine(r):
// new lines within quoted values are acceptable
p.UnreadRune()
@ -59,22 +71,48 @@ func lexQuotedString(p *TextParser) (string, *lexer.Error) {
}
}
func lexReturnUnescapedQuotedString(p *TextParser) (string, *lexer.Error) {
// remove quotes
s := p.String()
l := len(s)
s = s[1 : l-1]
// Unquoted removes quotes the content and unescapes the content
func lexQuotedStringEscaped(p *TextParser) (string, *lexer.Error) {
var result strings.Builder
if strings.ContainsRune(s, RuneEscape) {
// TODO: implement unescaping
err := NewError(p.Position(), s, "escaped characters", lexer.ErrNotImplemented)
return "", err
}
// append what was accepted before the escape character
_, _ = result.WriteString(p.String()[1:])
return s, nil
for {
r, _, err := p.ReadRune()
switch {
case err != nil:
// incomplete quoted
return "", NewErrIncompleteQuotedString(p)
case r == RuneQuotes:
// end
return result.String(), nil
case r == RuneEscape:
// escaped
r2, _, err := p.ReadRune()
switch {
case err != nil:
// incomplete escaped
return "", NewErrIncompleteEscaped(p)
case IsNewLine(r2):
// escaped new line, skip
p.UnreadRune()
p.AcceptNewLine()
default:
// TODO: check valid escape character and
// append to result
s := string([]rune{r, r2})
err := NewErrInvalidEscapeSequence(p, s)
return "", err
}
default:
// normal, append to result
_, _ = result.WriteRune(r)
}
}
}
// Unquoted removes quotes the content and unescapes the content
// Unquoted removes quotes and unescapes the content
func Unquoted(s string) (string, error) {
var p TextParser
if s == "" {

Loading…
Cancel
Save