feat: copied code over
This commit is contained in:
237
pkg/repr/saccharine/parse.go
Normal file
237
pkg/repr/saccharine/parse.go
Normal file
@@ -0,0 +1,237 @@
|
||||
package saccharine
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"git.maximhutz.com/max/lambda/pkg/iterator"
|
||||
"git.maximhutz.com/max/lambda/pkg/trace"
|
||||
)
|
||||
|
||||
type TokenIterator = iterator.Iterator[Token]
|
||||
|
||||
func parseRawToken(i *TokenIterator, expected Type) (*Token, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
|
||||
if tok, err := i.Next(); err != nil {
|
||||
return nil, err
|
||||
} else if tok.Type != expected {
|
||||
return nil, fmt.Errorf("expected token %v, got %v'", Name(expected), tok.Value)
|
||||
} else {
|
||||
return &tok, nil
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func passSoftBreaks(i *TokenIterator) {
|
||||
for {
|
||||
if _, err := parseRawToken(i, TokenSoftBreak); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func parseToken(i *TokenIterator, expected Type, ignoreSoftBreaks bool) (*Token, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
|
||||
if ignoreSoftBreaks {
|
||||
passSoftBreaks(i)
|
||||
}
|
||||
|
||||
return parseRawToken(i, expected)
|
||||
})
|
||||
}
|
||||
|
||||
func parseString(i *TokenIterator) (string, error) {
|
||||
if tok, err := parseToken(i, TokenAtom, true); err != nil {
|
||||
return "", trace.Wrap(err, "no variable (col %d)", i.Index())
|
||||
} else {
|
||||
return tok.Value, nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseBreak(i *TokenIterator) (*Token, error) {
|
||||
if tok, softErr := parseRawToken(i, TokenSoftBreak); softErr == nil {
|
||||
return tok, nil
|
||||
} else if tok, hardErr := parseRawToken(i, TokenHardBreak); hardErr == nil {
|
||||
return tok, nil
|
||||
} else {
|
||||
return nil, errors.Join(softErr, hardErr)
|
||||
}
|
||||
}
|
||||
|
||||
func parseList[U any](i *TokenIterator, fn func(*TokenIterator) (U, error), minimum int) ([]U, error) {
|
||||
results := []U{}
|
||||
|
||||
for {
|
||||
if u, err := fn(i); err != nil {
|
||||
if len(results) < minimum {
|
||||
return nil, trace.Wrap(err, "expected at least '%v' items, got only '%v'", minimum, len(results))
|
||||
}
|
||||
return results, nil
|
||||
} else {
|
||||
results = append(results, u)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func parseAbstraction(i *TokenIterator) (*Abstraction, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (*Abstraction, error) {
|
||||
if _, err := parseToken(i, TokenSlash, true); err != nil {
|
||||
return nil, trace.Wrap(err, "no function slash (col %d)", i.MustGet().Column)
|
||||
} else if parameters, err := parseList(i, parseString, 0); err != nil {
|
||||
return nil, err
|
||||
} else if _, err = parseToken(i, TokenDot, true); err != nil {
|
||||
return nil, trace.Wrap(err, "no function dot (col %d)", i.MustGet().Column)
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return NewAbstraction(parameters, body), nil
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func parseApplication(i *TokenIterator) (*Application, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (*Application, error) {
|
||||
if _, err := parseToken(i, TokenOpenParen, true); err != nil {
|
||||
return nil, trace.Wrap(err, "no openning brackets (col %d)", i.MustGet().Column)
|
||||
} else if expressions, err := parseList(i, parseExpression, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenCloseParen, true); err != nil {
|
||||
return nil, trace.Wrap(err, "no closing brackets (col %d)", i.MustGet().Column)
|
||||
} else {
|
||||
return NewApplication(expressions[0], expressions[1:]), nil
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func parseAtom(i *TokenIterator) (*Variable, error) {
|
||||
if tok, err := parseToken(i, TokenAtom, true); err != nil {
|
||||
return nil, trace.Wrap(err, "no variable (col %d)", i.Index())
|
||||
} else {
|
||||
return NewVariable(tok.Value), nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseStatements(i *TokenIterator) ([]Statement, error) {
|
||||
statements := []Statement{}
|
||||
|
||||
//nolint:errcheck
|
||||
parseList(i, parseBreak, 0)
|
||||
|
||||
for {
|
||||
if statement, err := parseStatement(i); err != nil {
|
||||
break
|
||||
} else if _, err := parseList(i, parseBreak, 1); err != nil && !i.Done() {
|
||||
break
|
||||
} else {
|
||||
statements = append(statements, statement)
|
||||
}
|
||||
}
|
||||
|
||||
return statements, nil
|
||||
}
|
||||
|
||||
func parseClause(i *TokenIterator, braces bool) (*Clause, error) {
|
||||
if braces {
|
||||
if _, err := parseToken(i, TokenOpenBrace, true); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
var stmts []Statement
|
||||
var last *DeclareStatement
|
||||
var err error
|
||||
var ok bool
|
||||
|
||||
if stmts, err = parseStatements(i); err != nil {
|
||||
return nil, err
|
||||
} else if len(stmts) == 0 {
|
||||
return nil, fmt.Errorf("no statements in clause")
|
||||
} else if last, ok = stmts[len(stmts)-1].(*DeclareStatement); !ok {
|
||||
return nil, fmt.Errorf("this clause contains no final return value (col %d)", i.MustGet().Column)
|
||||
}
|
||||
|
||||
if braces {
|
||||
if _, err := parseToken(i, TokenCloseBrace, true); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return NewClause(stmts[:len(stmts)-1], last.Value), nil
|
||||
}
|
||||
|
||||
func parseExpression(i *TokenIterator) (Expression, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (Expression, error) {
|
||||
passSoftBreaks(i)
|
||||
|
||||
switch peek := i.MustGet(); peek.Type {
|
||||
case TokenOpenParen:
|
||||
return parseApplication(i)
|
||||
case TokenSlash:
|
||||
return parseAbstraction(i)
|
||||
case TokenAtom:
|
||||
return parseAtom(i)
|
||||
case TokenOpenBrace:
|
||||
return parseClause(i, true)
|
||||
default:
|
||||
return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func parseLet(i *TokenIterator) (*LetStatement, error) {
|
||||
return iterator.Do(i, func(i *TokenIterator) (*LetStatement, error) {
|
||||
if parameters, err := parseList(i, parseString, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenAssign, true); err != nil {
|
||||
return nil, err
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return NewLet(parameters[0], parameters[1:], body), nil
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func parseDeclare(i *TokenIterator) (*DeclareStatement, error) {
|
||||
if value, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return NewDeclare(value), nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseStatement(i *TokenIterator) (Statement, error) {
|
||||
if let, letErr := parseLet(i); letErr == nil {
|
||||
return let, nil
|
||||
} else if declare, declErr := parseDeclare(i); declErr == nil {
|
||||
return declare, nil
|
||||
} else {
|
||||
return nil, errors.Join(letErr, declErr)
|
||||
}
|
||||
}
|
||||
|
||||
// Given a list of tokens, attempt to parse it into an syntax tree.
|
||||
func parse(tokens []Token) (Expression, error) {
|
||||
i := iterator.Of(tokens)
|
||||
|
||||
exp, err := parseClause(i, false)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if !i.Done() {
|
||||
return nil, fmt.Errorf("expected EOF, found more code (col %d)", i.MustGet().Column)
|
||||
}
|
||||
|
||||
return exp, nil
|
||||
}
|
||||
|
||||
// Convert a piece of valid saccharine code into an expression.
|
||||
func Parse(code string) (Expression, error) {
|
||||
tokens, err := Scan(code)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return parse(tokens)
|
||||
}
|
||||
Reference in New Issue
Block a user