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

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

decoder.go

@@ -1,83 +0,0 @@
-package ini
-
-import (
-	"bytes"
-	"io"
-	"strings"
-
-	"asciigoat.org/core"
-	"asciigoat.org/core/reflective"
-	"asciigoat.org/ini/parser"
-)
-
-const (
-	decPrefixLiteral = "ini: Decode"
-)
-
-var (
-	decINIPrefix = decPrefixLiteral[0:3]
-	decDecPrefix = decPrefixLiteral[5:]
-)
-
-// Decoder ...
-type Decoder struct {
-	io.Closer
-
-	out   *reflective.Reflection
-	p     *parser.Parser
-	queue []*token
-}
-
-// Decode ...
-func (dec *Decoder) Decode(v any) error {
-	defer dec.Close()
-
-	r, err := reflective.New(v)
-	switch e := err.(type) {
-	case *reflective.InvalidUnmarshalError:
-		// customize error
-		e.Prefix = decINIPrefix
-		e.Method = decDecPrefix
-	case *reflective.UnmarshalTypeError:
-		// customize error
-		e.Prefix = decPrefixLiteral
-	case nil:
-		// good reflection. Go!
-		dec.out = r
-		err = dec.p.Run()
-	}
-
-	return err
-}
-
-// NewDecoder creates a Decoder using the provided [io.Reader]
-// as source
-func NewDecoder(r io.Reader) *Decoder {
-	rc := core.NewReadCloser(r)
-	switch {
-	case rc == nil:
-		return nil
-	default:
-		dec := &Decoder{
-			p:      parser.NewParser(rc),
-			Closer: rc,
-		}
-
-		// callbacks
-		dec.p.OnToken = dec.parserOnToken
-		dec.p.OnError = dec.parserOnError
-
-		return dec
-	}
-}
-
-// NewDecoderBytes creates a Decoder using the provided bytes array
-// as source
-func NewDecoderBytes(b []byte) *Decoder {
-	return NewDecoder(bytes.NewReader(b))
-}
-
-// NewDecoderString creates a Decoder over a provided string of data
-func NewDecoderString(s string) *Decoder {
-	return NewDecoder(strings.NewReader(s))
-}

decoder_error.go

@@ -1,32 +0,0 @@
-package ini
-
-import (
-	"errors"
-	"log"
-
-	"asciigoat.org/core/lexer"
-)
-
-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 (*Decoder) newErrInvalidToken(t *token) *lexer.Error {
-	return newError(t.pos, t.value, "", errInvalidToken)
-}
-
-// parserOnError is the callback for lexer errors
-func (*Decoder) parserOnError(pos lexer.Position, content string, err error) error {
-	log.Printf("%s: %s %s: %q: %v", "ini", pos, "error", content, err)
-
-	return newError(pos, content, "", err)
-}

decoder_token.go

@@ -1,144 +0,0 @@
-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
-}

parser/lexer.go

@@ -5,42 +5,71 @@ import "asciigoat.org/core/lexer"
 // Run parses the source
 func (p *Parser) Run() error {
 	p.setDefaults()
+	p.pos.Reset()
 
 	return lexer.Run(p.lexStart)
 }
 
 func (p *Parser) lexStart() (lexer.StateFn, error) {
 	for {
-		r, _, err := p.p.ReadRune()
+		r, _, err := p.src.ReadRune()
 		switch {
 		case err != nil:
 			return p.emitError("", err)
 		case IsNewLine(r):
 			// new line
-			p.p.UnreadRune()
+			p.lexMoreNewLine(r)
-			p.p.AcceptNewLine()
 			p.stepLine()
 		case IsSpace(r):
 			// whitespace
-			p.stepString()
+			p.stepRune()
 		case IsCommentStart(r):
 			// switch to comment lexer
-			p.p.UnreadRune()
+			p.src.UnreadRune()
 			return p.lexComment, nil
 		case IsSectionStart(r):
 			// section
 			return p.lexSectionStart, nil
 		default:
 			// entry
-			p.p.UnreadRune()
+			p.src.UnreadRune()
 			return p.lexEntryStart, nil
 		}
 	}
 }
 
+func (p *Parser) lexMoreNewLine(r1 rune) {
+	// r1 is warrantied to be either '\r' or '\n'
+	r2, _, err := p.src.ReadRune()
+	switch r1 {
+	case '\n':
+		switch {
+		case r2 == '\r':
+			// LN CR
+		case err == nil:
+			// LN
+			p.src.UnreadRune()
+		default:
+			// LN EOF
+		}
+	case '\r':
+		switch {
+		case r2 == '\n':
+			// CR LN
+		case err == nil:
+			// CR
+			p.src.UnreadRune()
+		default:
+			// CR EOF
+		}
+	default:
+		panic("unreachable")
+	}
+}
+
 func (p *Parser) lexComment() (lexer.StateFn, error) {
 	// until the end of the line
-	p.p.AcceptAll(IsNotNewLine)
+	p.src.AcceptAll(IsNotNewLine)
 
 	err := p.emitString(TokenComment)
 	return p.lexStart, err
@@ -52,11 +81,11 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 	}
 
 	// remove whitespace between `[` and the name
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
+	if p.src.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	if !p.p.AcceptAll(IsName) {
+	if !p.src.AcceptAll(IsName) {
 		// no name
 		return p.emitError("section name missing", lexer.ErrUnacceptableRune)
 	}
@@ -65,12 +94,12 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 		return nil, err
 	}
 
-	// remove whitespace between the name and the closing `]`
+	// remove whitespace between the name andthe closing `]`
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
+	if p.src.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	r, _, err := p.p.ReadRune()
+	r, _, err := p.src.ReadRune()
 	switch {
 	case err != nil:
 		return p.emitError("", err)
@@ -83,17 +112,17 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 }
 
 func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
-	p.p.AcceptAll(IsName)
+	p.src.AcceptAll(IsName)
 	if err := p.emitString(TokenFieldKey); err != nil {
 		return nil, err
 	}
 
 	// ignore whitespace between key and the '=' sign
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
+	if p.src.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	r, _, err := p.p.ReadRune()
+	r, _, err := p.src.ReadRune()
 	switch {
 	case err != nil:
 		return p.emitError("", err)
@@ -102,11 +131,11 @@ func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
 	}
 
 	// ignore whitespace between the '=' and the value
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
+	if p.src.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	p.p.AcceptAll(IsNotNewLine)
+	p.src.AcceptAll(IsNotNewLine)
 	if err := p.emitString(TokenFieldValue); err != nil {
 		return nil, err
 	}

parser/parser.go

@@ -1,4 +1,4 @@
-// Package parser parses ini-style files
+// Package parser parses dosini-style files
 package parser
 
 import (
@@ -8,9 +8,10 @@ import (
 	"asciigoat.org/core/lexer"
 )
 
-// Parser parses a ini-style document
+// Parser parses a dosini-style document
 type Parser struct {
-	p TextParser
+	src *lexer.Reader
+	pos lexer.Position
 
 	// OnToken is called for each identified token. if it returns an error
 	// parsing is interrupted.
@@ -50,13 +51,15 @@ func (p *Parser) setDefaults() {
 }
 
 func (p *Parser) emitString(typ TokenType) error {
-	pos, s := p.p.Emit()
+	s := p.src.Emit()
-	return p.OnToken(pos, typ, s)
+	err := p.OnToken(p.pos, typ, s)
+	p.pos.StepN(len(s))
+
+	return err
 }
 
 func (p *Parser) emitError(content string, err error) (lexer.StateFn, error) {
-	pos := p.p.Position()
+	err2 := p.OnError(p.pos, content, err)
-	err2 := p.OnError(pos, content, err)
 	switch {
 	case err2 != nil:
 		// return wrapped error
@@ -74,25 +77,33 @@ func (p *Parser) emitInvalidRune(r rune) (lexer.StateFn, error) {
 // stepLine discards the data and moves the position
 // to the next line.
 func (p *Parser) stepLine() {
-	p.p.StepLine()
+	p.src.Discard()
+	p.pos.StepLine()
+}
+
+// stepRune discards the data and moves the position
+// one rune forward on the same line.
+func (p *Parser) stepRune() {
+	p.src.Discard()
+	p.pos.Step()
 }
 
 // stepString discards the data and moves the position
 // forward on the same line the length of the discarded
 // content.
 func (p *Parser) stepString() {
-	p.p.Step()
+	s := p.src.Emit()
+	p.pos.StepN(len(s))
 }
 
-// NewParser creates a ini-style parser using
+// NewParser creates a dosini-style parser using
 // an [io.Reader] as source
 func NewParser(r io.Reader) *Parser {
-	var p *Parser
+	if r == nil {
-
+		return nil
-	if r != nil {
-		p = new(Parser)
-		p.p.Init(r)
 	}
 
-	return p
+	return &Parser{
+		src: lexer.NewReader(r),
+	}
 }

parser/text.go

@@ -1,102 +0,0 @@
-package parser
-
-import (
-	"bytes"
-	"io"
-	"strings"
-
-	"asciigoat.org/core/lexer"
-)
-
-// TextParser is a generic text parser.
-type TextParser struct {
-	*lexer.Reader
-	pos lexer.Position
-}
-
-// Init initializes the [TextParser] with a non-nil [io.Reader].
-func (p *TextParser) Init(r io.Reader) {
-	switch {
-	case p == nil || r == nil:
-		panic("invalid call")
-	case p.Reader != nil:
-		panic("parser already initialized")
-	default:
-		p.Reader = lexer.NewReader(r)
-		p.pos.Reset()
-	}
-}
-
-// InitBytes initializes the [TextParser] with a byte array
-func (p *TextParser) InitBytes(b []byte) {
-	p.Init(bytes.NewReader(b))
-}
-
-// InitString initializes the [TextParser] with a byte array
-func (p *TextParser) InitString(s string) {
-	p.Init(strings.NewReader(s))
-}
-
-// Discard shadows [lexer.Reader]'s, and takes in consideration
-// new lines on the discarded data when moving the position
-func (*TextParser) Discard() {
-	// TODO: consider new lines
-	panic("not implemented")
-}
-
-// Emit returns the accepted text, its position, and
-// moves the cursor position accordingly
-func (p *TextParser) Emit() (lexer.Position, string) {
-	pos := p.pos
-	s := p.Reader.Emit()
-	// TODO: consider new lines
-	p.pos.StepN(len(s))
-
-	return pos, s
-}
-
-// Step discards what's been accepted and increments the
-// position assuming they all increment the column counter
-func (p *TextParser) Step() {
-	s := p.Reader.Emit()
-	p.pos.StepN(len(s))
-}
-
-// StepLine discards what's been accepted and moves then
-// position to the beginning of the next line
-func (p *TextParser) StepLine() {
-	p.Reader.Discard()
-	p.pos.StepLine()
-}
-
-// Position returns the position of the first character
-// of the accepted text
-func (p *TextParser) Position() lexer.Position {
-	return p.pos
-}
-
-// AcceptNewLine checks if next is a new line.
-// It accepts "\n", "\n\r", "\r" and "\r\n".
-func (p *TextParser) AcceptNewLine() bool {
-	r1, _, err := p.ReadRune()
-	switch {
-	case err != nil:
-		return false
-	case r1 == '\n':
-		p.AcceptRune('\r')
-		return true
-	case r1 == '\r':
-		p.AcceptRune('\n')
-		return true
-	default:
-		p.UnreadRune()
-		return false
-	}
-}
-
-// AcceptRune checks if next is the specified rune
-func (p *TextParser) AcceptRune(r rune) bool {
-	return p.Accept(func(r2 rune) bool {
-		return r == r2
-	})
-}