hakurei/internal/rosa/azalea/azalea.go

// Package azalea implements a proof-of-concept, domain-specific language for
// Rosa OS software packaging.
package azalea

import (
	"errors"
	"io"
	"strconv"
	"strings"
	"text/scanner"
)

// idents are runes accepted in an identifier.
var idents = [...]bool{
	'0': true, '1': true, '2': true, '3': true, '4': true, '5': true, '6': true,
	'7': true, '8': true, '9': true,

	'A': true, 'B': true, 'C': true, 'D': true, 'E': true, 'F': true, 'G': true,
	'H': true, 'I': true, 'J': true, 'K': true, 'L': true, 'M': true, 'N': true,
	'O': true, 'P': true, 'Q': true, 'R': true, 'S': true, 'T': true, 'U': true,
	'V': true, 'W': true, 'X': true, 'Y': true, 'Z': true,

	'a': true, 'b': true, 'c': true, 'd': true, 'e': true, 'f': true, 'g': true,
	'h': true, 'i': true, 'j': true, 'k': true, 'l': true, 'm': true, 'n': true,
	'o': true, 'p': true, 'q': true, 'r': true, 's': true, 't': true, 'u': true,
	'v': true, 'w': true, 'x': true, 'y': true, 'z': true,

	'-': true, '_': true,
}

// TokenError describes an unexpected token.
type TokenError [2]rune

func (e TokenError) Error() string {
	return "expected " + scanner.TokenString(e[0]) +
		", found " + scanner.TokenString(e[1])
}

// ExprError is an unexpected token encountered while parsing an expression.
type ExprError rune

func (e ExprError) Error() string {
	return "unexpected token " + scanner.TokenString(rune(e))
}

// must1 returns v, or panics if err is not nil.
func must1[T any](v T, err error) T {
	if err != nil {
		panic(err)
	}
	return v
}

// parser retains the current token.
type parser struct {
	s   scanner.Scanner
	tok rune
}

// scan advances the underlying scanner to the next token, storing its result.
func (p *parser) scan() rune { p.tok = p.s.Scan(); return p.tok }

// expects panics with [TokenError] for an unexpected tok.
func (p *parser) expects(expects rune) {
	if p.tok != expects {
		panic(TokenError{expects, p.tok})
	}
}

// scanAs advances the scanner for an expected token.
func (p *parser) scanAs(expects rune) { p.scan(); p.expects(expects) }

// An Int is the value represented by an integer literal.
type Int int64

func (v Int) GoString() string {
	return "azalea.Int(" + strconv.FormatInt(int64(v), 10) + ")"
}

// parseInt parses the current token as a base 10 representation of a 64-bit
// signed integer.
func (p *parser) parseInt() Int {
	v, err := strconv.ParseInt(p.s.TokenText(), 10, 64)
	return must1(Int(v), err)
}

// A String holds the unquoted content of a string literal.
type String string

func (v String) GoString() string {
	return "azalea.String(" + strconv.Quote(string(v)) + ")"
}

// parseString parses the current token as a string.
func (p *parser) parseString() String {
	s, err := strconv.Unquote(p.s.TokenText())
	return must1(String(s), err)
}

// An Ident holds the name of an identifier.
type Ident string

func (v Ident) GoString() string {
	return "azalea.Ident(" + strconv.Quote(string(v)) + ")"
}

// A Val are statements joined by the '+' operator. Only the [String] type
// supports concatenation.
type Val []any

// parseVal parses until the end of the [Val].
func (p *parser) parseVal() (v Val) {
	v = append(v, p.parseExpr())
	for p.tok == '+' {
		p.scan()
		v = append(v, p.parseExpr())
	}
	return
}

// An Array holds statements in an array.
type Array []Val

// A KV holds a key/value pair.
type KV struct {
	K String
	V Val
}

// An Arg represents an argument of [Func].
type Arg struct {
	K []Ident
	V Val
	R bool
}

// Func is a function call or package declaration.
type Func struct {
	// Function or package identifier.
	Ident Ident
	// Whether this is a package declaration.
	Package bool
	// Key-value arguments.
	Args []Arg
}

// parseExpr parses the current expression.
func (p *parser) parseExpr() any {
	switch p.tok {
	case scanner.Int:
		v := p.parseInt()
		p.scan()
		return v

	case scanner.String, scanner.RawString:
		v := p.parseString()
		p.scan()
		return v

	case scanner.Ident:
		var v Func
		v.Ident = Ident(p.s.TokenText())
		if v.Package = v.Ident == "package"; v.Package {
			p.scanAs(scanner.Ident)
			v.Ident = Ident(p.s.TokenText())
		}

		p.scan()
		switch p.tok {
		case '{':
			for {
				p.scan()
				switch p.tok {
				case '}':
					p.scan()
					return v

				case scanner.Ident:
					break

				default:
					panic(TokenError{scanner.Ident, p.tok})
				}

				arg := Arg{K: []Ident{Ident(p.s.TokenText())}}
				delim := true
			arg:
				for {
					p.scan()
					switch p.tok {
					case ',':
						if delim {
							delim = false
							continue
						}
						panic(ExprError(p.tok))

					case scanner.Ident:
						if delim {
							panic(TokenError{',', p.tok})
						}
						delim = true
						arg.K = append(arg.K, Ident(p.s.TokenText()))

					default:
						break arg
					}
				}
				switch p.tok {
				case '=':
					break

				case '#':
					arg.R = true
					p.scanAs('=')

				default:
					panic(TokenError{'=', p.tok})
				}
				p.scan()
				arg.V = p.parseVal()
				v.Args = append(v.Args, arg)
				p.expects(';')
			}

		default:
			return v.Ident
		}

	case '{':
		var v []KV
		for {
			p.scan()
			switch p.tok {
			case '}':
				p.scan()
				return v

			case scanner.String:
				pair := KV{K: p.parseString()}
				p.scan()
				switch p.tok {
				case ';':
					break

				case ':':
					p.scan()
					pair.V = p.parseVal()
					p.expects(';')
					break

				default:
					panic(ExprError(p.tok))
				}
				v = append(v, pair)

			default:
				panic(ExprError(p.tok))
			}
		}

	case '[':
		var (
			v     Array
			delim bool
		)
		p.scan()
		for {
			switch p.tok {
			case ',':
				if delim {
					p.scan()
					delim = false
					continue
				}
				panic(ExprError(','))
			case ']':
				p.scan()
				return v
			case scanner.EOF:
				panic(ExprError(scanner.EOF))
			default:
				if delim {
					panic(TokenError{',', p.tok})
				}
				delim = true
				break
			}
			v = append(v, p.parseVal())
		}

	default:
		panic(ExprError(p.tok))
	}
}

// ScanError is the error count parsing all expressions.
type ScanError int

func (ScanError) Error() string {
	return "aborting due to scanning errors"
}

// Parse parses expressions from r.
func Parse(r io.Reader) (e []any, err error) {
	r, err = insertSemicolons(r)
	var p parser
	p.s.Init(r)

	p.s.Mode = scanner.ScanIdents |
		scanner.ScanInts |
		scanner.ScanStrings |
		scanner.ScanRawStrings |
		scanner.ScanComments |
		scanner.SkipComments
	p.s.IsIdentRune = isIdentRune

	defer func() {
		v := recover()
		if v == nil {
			return
		}

		_err, ok := v.(error)
		if !ok {
			panic(v)
		}

		if err == nil {
			err = _err
			return
		}
		err = errors.Join(err, _err)
	}()

	p.scan()
	for p.tok != scanner.EOF {
		e = append(e, p.parseExpr())
	}

	if p.s.ErrorCount != 0 {
		err = ScanError(p.s.ErrorCount)
	}
	return
}
func isIdentRune(ch rune, i int) bool {
	if i == 0 && ch >= '0' && ch <= '9' {
		return false
	}
	return ch > 0 && ch < rune(len(idents)) && idents[ch]
}
func insertSemicolons(r io.Reader) (io.Reader, error) {
	var s scanner.Scanner
	s.Init(r)
	s.Mode = scanner.ScanIdents |
		scanner.ScanInts |
		scanner.ScanStrings |
		scanner.ScanRawStrings |
		scanner.ScanComments |
		scanner.SkipComments
	s.Whitespace = 0
	s.IsIdentRune = isIdentRune

	var buf strings.Builder
	nlsemi := false
	nlcomma := false
	b := new(RuneStack)

	tok := s.Scan()
	for tok != scanner.EOF {
		switch tok {
		case '\n':
			if b.Peek() == '{' && nlsemi {
				buf.WriteRune(';')
				nlsemi = false
			}
			if b.Peek() == '[' && nlcomma {
				buf.WriteRune(',')
				nlcomma = false
			}
		case ';':
			buf.WriteRune(tok)
			nlsemi = false
		case ',':
			buf.WriteRune(tok)
			nlcomma = false
		case '{', '[':
			nlsemi = false
			nlcomma = false
			buf.WriteRune(tok)
			b.Push(tok)
		case '}', ']':
			r := b.Pop()
			if r == '{' {
				if nlsemi {
					buf.WriteRune(';')
				}
				nlcomma = true
				nlsemi = true
			}
			if r == '[' {
				if nlcomma {
					buf.WriteRune(',')
				}
				nlsemi = true
			}
			buf.WriteRune(tok)
			if b.Peek() == '}' && nlsemi {
				buf.WriteRune(';')
			}
			if b.Peek() == ']' && nlcomma {
				buf.WriteRune(',')
			}
		case '+', ':', '=':
			buf.WriteRune(tok)
			nlsemi = false
			nlcomma = false
		case scanner.String, scanner.RawString, scanner.Int, scanner.Ident:
			buf.WriteString(s.TokenText())
			if b.Peek() == '{' {
				nlsemi = true
			} else if b.Peek() == '[' {
				nlcomma = true
			}
		default:
			buf.WriteString(s.TokenText())
		}

		tok = s.Scan()
	}
	return strings.NewReader(buf.String()), nil
}

type Stack[T any] interface {
	Push(T)
	Pop() T
	Peek() T
	Length() int
}
type RuneStack struct {
	arr []rune
	Stack[rune]
}

func (s *RuneStack) Push(r rune) {
	s.arr = append(s.arr, r)
}

func (s *RuneStack) String() string {
	return string(s.arr)
}
func (s *RuneStack) Peek() rune {
	if s.Length() > 0 {
		return s.arr[s.Length()-1]
	}
	return 0
}
func (s *RuneStack) Pop() rune {
	v := s.Peek()
	if s.Length() > 1 {
		s.arr = s.arr[:s.Length()-1]
	} else {
		s.arr = make([]rune, 0)
	}
	return v
}
func (s *RuneStack) Length() int {
	return len(s.arr)
}