parser: Unescaped [WIP]

Signed-off-by: Alejandro Mery <amery@jpi.io>

.vscode/settings.json

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

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
 	}
 }

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

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=

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)
+}

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 == "" {