build-sys: use local darvaza.org/core [DO-NOT-MERGE]

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

parser/error.go

@@ -35,28 +35,9 @@ 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,34 +33,22 @@ 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 "", false, NewErrIncompleteQuotedString(p)
+			return "", NewErrIncompleteQuotedString(p)
 		case r == RuneQuotes:
-			// end, just remove the quotes
+			// end, remove quotes and process escaped characters
-			s := p.String()
+			return lexReturnUnescapedQuotedString(p)
-			l := len(s)
-			return s[1 : l-1], true, nil
 		case r == RuneEscape:
-			// things just got complicated...
+			// escaped, take another
-			p.UnreadRune()
+			_, _, err := p.ReadRune()
-			return "", false, nil
+			if err != nil {
+				// incomplete
+				return "", NewErrIncompleteQuotedString(p)
+			}
 		case IsNewLine(r):
 			// new lines within quoted values are acceptable
 			p.UnreadRune()
@@ -71,48 +59,22 @@ func lexQuotedStringNoEscape(p *TextParser) (string, bool, *lexer.Error) {
 	}
 }
 
-// Unquoted removes quotes the content and unescapes the content
+func lexReturnUnescapedQuotedString(p *TextParser) (string, *lexer.Error) {
-func lexQuotedStringEscaped(p *TextParser) (string, *lexer.Error) {
+	// remove quotes
-	var result strings.Builder
+	s := p.String()
+	l := len(s)
+	s = s[1 : l-1]
 
-	// append what was accepted before the escape character
+	if strings.ContainsRune(s, RuneEscape) {
-	_, _ = result.WriteString(p.String()[1:])
+		// TODO: implement unescaping
-
+		err := NewError(p.Position(), s, "escaped characters", lexer.ErrNotImplemented)
-	for {
+		return "", err
-		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)
-		}
 	}
+
+	return s, nil
 }
 
-// Unquoted removes quotes and unescapes the content
+// Unquoted removes quotes the content and unescapes the content
 func Unquoted(s string) (string, error) {
 	var p TextParser
 	if s == "" {