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

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

basic/error.go

@@ -4,28 +4,19 @@ import (
 	"errors"
 
 	"asciigoat.org/core/lexer"
+	"asciigoat.org/ini/parser"
 )
 
 var (
 	errInvalidToken = errors.New("invalid token")
 )
 
-func newError(pos lexer.Position, content, hint string, err error) *lexer.Error {
-	return &lexer.Error{
-		Line:    pos.Line,
-		Column:  pos.Column,
-		Content: content,
-		Hint:    hint,
-		Err:     err,
-	}
-}
-
 func newErrInvalidToken(t *token) *lexer.Error {
-	return newError(t.pos, t.value, "", errInvalidToken)
+	return parser.NewError(t.pos, t.value, "", errInvalidToken)
 }
 
 func (dec *decoder) OnError(pos lexer.Position, content string, err error) error {
-	err = newError(pos, content, "", err)
+	err = parser.NewError(pos, content, "", err)
 	dec.executeFinal()
 	return err
 }

parser/comma_array.go

@@ -1,6 +1,8 @@
 package parser
 
 import (
+	"strings"
+
 	"asciigoat.org/core/lexer"
 )
 
@@ -46,18 +48,13 @@ func (p *commaArrayParser) lexWord() (lexer.StateFn, error) {
 			_, s := p.Emit()
 			p.out = append(p.out, s)
 			return nil, err
-		case r == RuneEscape:
-			// escaped
-			r2, _, err := p.ReadRune()
-			switch {
-			case err != nil:
-				// incomplete
-				return nil, NewErrIncompleteEscaped(&p.TextParser)
-			case IsNewLine(r2):
-				// escaped new line
-				p.UnreadRune()
-				p.AcceptNewLine()
-			}
+		case r == ',':
+			// done
+			_, s := p.Emit()
+			// remove comma, trim and append to output
+			s = strings.TrimRightFunc(s[:len(s)-1], IsSpace)
+			p.out = append(p.out, s)
+			return p.lexStart, nil
 		}
 	}
 }
@@ -79,7 +76,8 @@ func (p *commaArrayParser) Run() ([]string, error) {
 	return p.out, err
 }
 
-// SplitCommaArray splits
+// SplitCommaArray splits comma separated strings, removing whitespace
+// and respecting quoted literals.
 func SplitCommaArray(s string) ([]string, error) {
 	if s != "" {
 		var p commaArrayParser

parser/error.go

@@ -6,6 +6,17 @@ import (
 	"asciigoat.org/core/lexer"
 )
 
+// NewError creates a lexer.Error using a lexer.Position
+func NewError(pos lexer.Position, content, hint string, err error) *lexer.Error {
+	return &lexer.Error{
+		Line:    pos.Line,
+		Column:  pos.Column,
+		Content: content,
+		Hint:    hint,
+		Err:     err,
+	}
+}
+
 // ErrPlusPosition returns a copy of the given [lexer.Error]
 // offsetting the Line/Column information.
 func ErrPlusPosition(pos lexer.Position, e *lexer.Error) *lexer.Error {
@@ -14,13 +25,7 @@ func ErrPlusPosition(pos lexer.Position, e *lexer.Error) *lexer.Error {
 		Column: e.Column,
 	})
 
-	return &lexer.Error{
-		Line:    pos.Line,
-		Column:  pos.Column,
-		Content: e.Content,
-		Hint:    e.Hint,
-		Err:     e.Err,
-	}
+	return NewError(pos, e.Content, e.Hint, e.Err)
 }
 
 // NewErrIncompleteQuotedString returns a [lexer.Error]
@@ -30,22 +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 &lexer.Error{
-		Line:    pos.Line,
-		Column:  pos.Column,
-		Content: s,
-		Hint:    hint,
-		Err:     fs.ErrInvalid,
-	}
+	return NewError(pos, s, hint, fs.ErrInvalid)
 }

parser/parser.go

@@ -31,13 +31,7 @@ func defaultOnToken(pos lexer.Position, typ TokenType, value string) error {
 func defaultOnError(pos lexer.Position, content string, err error) error {
 	log.Printf("%s:%v:%v: %q: %s", "error", pos.Line, pos.Column, content, err)
 
-	return lexer.Error{
-		Line:   pos.Line,
-		Column: pos.Column,
-
-		Content: content,
-		Err:     err,
-	}
+	return NewError(pos, content, "", err)
 }
 
 func (p *Parser) setDefaults() {

parser/text_quoted.go

@@ -1,11 +1,13 @@
 package parser
 
 import (
+	"strings"
+
 	"asciigoat.org/core/lexer"
 )
 
 // AcceptQuotedString consumes a quoted string from the source
-// and returns it unquoted.
+// and returns it unquoted and unescaped
 func (p *TextParser) AcceptQuotedString() (string, bool, error) {
 	r, _, err := p.ReadRune()
 	switch {
@@ -31,33 +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
-			s := p.String()
-			l := len(s)
-			return s[1 : l-2], true, nil
+			// end, remove quotes and process escaped characters
+			return lexReturnUnescapedQuotedString(p)
 		case r == RuneEscape:
-			// things just got complicated...
-			return "", false, nil
+			// escaped, take another
+			_, _, err := p.ReadRune()
+			if err != nil {
+				// incomplete
+				return "", NewErrIncompleteQuotedString(p)
+			}
 		case IsNewLine(r):
 			// new lines within quoted values are acceptable
 			p.UnreadRune()
@@ -68,28 +59,22 @@ func lexQuotedStringNoEscape(p *TextParser) (string, bool, *lexer.Error) {
 	}
 }
 
-func lexQuotedStringEscaped(*TextParser) (string, *lexer.Error) {
-	return "", nil
+func lexReturnUnescapedQuotedString(p *TextParser) (string, *lexer.Error) {
+	// remove quotes
+	s := p.String()
+	l := len(s)
+	s = s[1 : l-1]
+
+	if strings.ContainsRune(s, RuneEscape) {
+		// TODO: implement unescaping
+		err := NewError(p.Position(), s, "escaped characters", lexer.ErrNotImplemented)
+		return "", err
+	}
+
+	return s, nil
 }
 
-//	// escaped. append partial
-//	mark = lexQuotedAppendPartial(p, &buf, mark)
-//
-//	r2, _, err := p.ReadRune()
-//	switch {
-//	case err != nil:
-//		// incomplete
-//		return "", NewErrIncompleteQuotedString(p)
-//	case IsNewLine(r2):
-//		// escaped new line
-//		p.UnreadRune()
-//		p.AcceptNewLine()
-//		mark = lexQuotedAppendNewLine(p, &buf, mark)
-//	default:
-//		// bad escaped
-//	}
-
-// 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 == "" {