100 lines
2.8 KiB
Go
100 lines
2.8 KiB
Go
package parser
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"git.maximhutz.com/max/lambda/pkg/iterator"
|
|
"git.maximhutz.com/max/lambda/pkg/lambda"
|
|
"git.maximhutz.com/max/lambda/pkg/tokenizer"
|
|
)
|
|
|
|
func ParseExpression(i *iterator.Iterator[tokenizer.Token]) (lambda.Expression, error) {
|
|
token, err := i.Next()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Could not get next token: %w", err)
|
|
}
|
|
|
|
switch token.Type {
|
|
case tokenizer.TokenVariable:
|
|
return lambda.NewVariable(token.Value), nil
|
|
case tokenizer.TokenDot:
|
|
return nil, fmt.Errorf("Token '.' found without a corresponding slash (column %d).", token.Index)
|
|
case tokenizer.TokenSlash:
|
|
atoms := []string{}
|
|
|
|
for {
|
|
atom, atom_err := i.Next()
|
|
if atom_err != nil {
|
|
return nil, fmt.Errorf("Could not find parameter or terminator of function: %w", atom_err)
|
|
} else if atom.Type == tokenizer.TokenVariable {
|
|
atoms = append(atoms, atom.Value)
|
|
} else if atom.Type == tokenizer.TokenDot {
|
|
break
|
|
} else {
|
|
return nil, fmt.Errorf("Expected function parameter or terminator, got '%v' (column %d).", atom.Value, atom.Index)
|
|
}
|
|
}
|
|
|
|
if len(atoms) == 0 {
|
|
return nil, fmt.Errorf("Every function must have atleast one parameter (column %d)", token.Index)
|
|
}
|
|
|
|
body, body_err := ParseExpression(i)
|
|
if body_err != nil {
|
|
return nil, fmt.Errorf("Could not parse function body: %w", body_err)
|
|
}
|
|
|
|
// Construction.
|
|
result := body
|
|
for i := len(atoms) - 1; i >= 0; i-- {
|
|
result = lambda.NewAbstraction(atoms[i], result)
|
|
}
|
|
|
|
return result, nil
|
|
case tokenizer.TokenOpenParen:
|
|
fn, fn_err := ParseExpression(i)
|
|
if fn_err != nil {
|
|
return nil, fmt.Errorf("Could not parse call function: %w", fn_err)
|
|
}
|
|
|
|
args := []lambda.Expression{}
|
|
|
|
for {
|
|
if next, next_err := i.Peek(); next_err == nil && next.Type == tokenizer.TokenCloseParen {
|
|
break
|
|
}
|
|
|
|
arg, arg_err := ParseExpression(i)
|
|
if arg_err != nil {
|
|
return nil, fmt.Errorf("Could not parse call argument: %w", arg_err)
|
|
}
|
|
|
|
args = append(args, arg)
|
|
}
|
|
|
|
close, close_err := i.Next()
|
|
if close_err != nil {
|
|
return nil, fmt.Errorf("Could not parse call terminating parenthesis: %w", close_err)
|
|
} else if close.Type != tokenizer.TokenCloseParen {
|
|
return nil, fmt.Errorf("Expected call terminating parenthesis, got '%v' (column %v).", close.Value, close.Index)
|
|
}
|
|
|
|
// Construction.
|
|
result := fn
|
|
for _, arg := range args {
|
|
result = lambda.NewApplication(result, arg)
|
|
}
|
|
|
|
return result, nil
|
|
case tokenizer.TokenCloseParen:
|
|
return nil, fmt.Errorf("Token ')' found without a corresponding openning parenthesis (column %d).", token.Index)
|
|
default:
|
|
return nil, fmt.Errorf("Unknown token '%v' (column %d).", token.Value, token.Index)
|
|
}
|
|
}
|
|
|
|
func GetTree(tokens []tokenizer.Token) (lambda.Expression, error) {
|
|
i := iterator.New(tokens)
|
|
return ParseExpression(&i)
|
|
}
|