You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

542 lines
10 KiB
Go

package moon
import (
"bufio"
"bytes"
"fmt"
"io"
"sort"
"strconv"
"strings"
"time"
)
type nodeType int
const (
n_error nodeType = iota
n_root
n_comment
n_assignment
n_string
n_number
n_list
n_object
n_variable
n_bool
n_duration
)
var indent = " "
type context struct {
public map[string]interface{}
private map[string]interface{}
}
func newContext() *context {
return &context{make(map[string]interface{}), make(map[string]interface{})}
}
func (c *context) get(name string) (interface{}, bool) {
if v, ok := c.public[name]; ok {
return v, true
}
if v, ok := c.private[name]; ok {
return v, true
}
return nil, false
}
type node interface {
Type() nodeType
parse(*parser) error
pretty(io.Writer, string) error
eval(*context) (interface{}, error)
}
type rootNode struct {
children []node
}
func newRootNode() node {
return &rootNode{children: make([]node, 0, 8)}
}
func (n *rootNode) Type() nodeType {
return n_root
}
func (n *rootNode) parse(p *parser) error {
for {
t := p.next()
switch t.t {
case t_error:
return fmt.Errorf("parse error: saw lex error while parsing root node: %v", t)
case t_eof:
return nil
case t_comment:
n.addChild(&commentNode{t.s})
case t_name:
nn := &assignmentNode{name: t.s}
if err := nn.parse(p); err != nil {
return err
}
n.addChild(nn)
case t_variable:
nn := &assignmentNode{name: t.s, unexported: true}
if err := nn.parse(p); err != nil {
return err
}
n.addChild(nn)
default:
return fmt.Errorf("parse error: unexpected token type %v while parsing root node", t.t)
}
}
}
func (n *rootNode) addChild(child node) {
if n.children == nil {
n.children = make([]node, 0, 8)
}
n.children = append(n.children, child)
}
func (n *rootNode) String() string {
var buf bytes.Buffer
buf.WriteString("{")
for _, child := range n.children {
fmt.Fprintf(&buf, "%s, ", child)
}
if buf.Len() > 1 {
buf.Truncate(buf.Len() - 2)
}
buf.WriteString("}")
return buf.String()
}
func (n *rootNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sroot:\n", prefix)
for _, child := range n.children {
if err := child.pretty(w, prefix+indent); err != nil {
return err
}
}
return nil
}
func (n *rootNode) eval(ctx *context) (interface{}, error) {
for _, child := range n.children {
if _, err := child.eval(ctx); err != nil {
return nil, err
}
}
return nil, nil
}
type commentNode struct {
body string
}
func (n *commentNode) Type() nodeType {
return n_comment
}
func (n *commentNode) parse(p *parser) error {
return nil
}
func (n *commentNode) String() string {
return fmt.Sprintf("{comment: %s}", n.body)
}
func (n *commentNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%scomment:\n", prefix)
r := bufio.NewReader(strings.NewReader(n.body))
for {
line, err := r.ReadString('\n')
if err == io.EOF {
if line != "" {
fmt.Fprintf(w, "%s%s%s\n", prefix, indent, line)
}
break
}
if err != nil {
return err
}
fmt.Fprintf(w, "%s%s%s\n", prefix, indent, line)
}
return nil
}
func (n *commentNode) eval(ctx *context) (interface{}, error) {
return nil, nil
}
type assignmentNode struct {
name string
value node
unexported bool
}
func (n *assignmentNode) Type() nodeType {
return n_assignment
}
func (n *assignmentNode) parse(p *parser) error {
t := p.next()
switch t.t {
case t_error:
return fmt.Errorf("parse error: saw lex error while parsing assignment node: %v", t.s)
case t_eof:
return fmt.Errorf("parse error: unexpected eof in assignment node")
case t_object_separator:
default:
return fmt.Errorf("parse error: unexpected %v token after name, expected =", t.t)
}
v, err := p.parseValue()
if err != nil {
return err
}
n.value = v
return nil
}
func (n *assignmentNode) String() string {
return fmt.Sprintf("{assign: name=%s, val=%v}", n.name, n.value)
}
func (n *assignmentNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sassign:\n", prefix)
fmt.Fprintf(w, "%s%sname:\n", prefix, indent)
fmt.Fprintf(w, "%s%s%s%s\n", prefix, indent, indent, n.name)
fmt.Fprintf(w, "%s%svalue:\n", prefix, indent)
if err := n.value.pretty(w, prefix+indent+indent); err != nil {
return err
}
return nil
}
func (n *assignmentNode) eval(ctx *context) (interface{}, error) {
if _, ok := ctx.get(n.name); ok {
return nil, fmt.Errorf("invalid re-declaration: %s", n.name)
}
v, err := n.value.eval(ctx)
if err != nil {
return nil, err
}
if n.unexported {
ctx.private[n.name] = v
} else {
ctx.public[n.name] = v
}
return nil, nil
}
func (n *assignmentNode) isHidden() bool {
return strings.HasPrefix(n.name, ".")
}
type stringNode string
func (s *stringNode) Type() nodeType {
return n_string
}
func (s *stringNode) parse(p *parser) error {
t := p.next()
if t.t != t_string {
return fmt.Errorf("unexpected %s while looking for string token", t.t)
}
*s = stringNode(t.s)
return nil
}
func (s *stringNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sstring:\n", prefix)
_, err := fmt.Fprintf(w, "%s%s%s\n", prefix, indent, string(*s))
return err
}
func (s *stringNode) eval(ctx *context) (interface{}, error) {
return string(*s), nil
}
type numberType int
const (
num_int numberType = iota
num_float
num_complex
)
type numberNode struct {
t numberType
c complex128
i int
f float64
}
func (n *numberNode) Type() nodeType {
return n_number
}
func (n *numberNode) parse(p *parser) error {
t := p.next()
if t.t != t_real_number {
return fmt.Errorf("unexpected %s token while parsing number", t.t)
}
if p.peek().t == t_imaginary_number {
n.t = num_complex
s := t.s + p.next().s
if _, err := fmt.Sscan(s, &n.c); err != nil {
return fmt.Errorf("ungood imaginary number format %s: %s", s, err)
}
return nil
}
i, err := strconv.ParseInt(t.s, 0, 64)
if err == nil {
n.t = num_int
n.i = int(i)
return nil
}
f, err := strconv.ParseFloat(t.s, 64)
if err == nil {
n.t = num_float
n.f = f
return nil
}
return fmt.Errorf("this token broke the number parser: %s", t)
}
func (n *numberNode) pretty(w io.Writer, prefix string) error {
v, err := n.eval(nil)
if err != nil {
return err
}
fmt.Fprintf(w, "%snumber:\n%s%s%v\n", prefix, prefix, indent, v)
return nil
}
func (n *numberNode) eval(ctx *context) (interface{}, error) {
switch n.t {
case num_int:
return n.i, nil
case num_float:
return n.f, nil
case num_complex:
return n.c, nil
default:
panic("whoerps")
}
}
type listNode []node
func (l *listNode) Type() nodeType {
return n_list
}
func (l *listNode) parse(p *parser) error {
if p.peek().t == t_list_end {
p.next()
return nil
}
if n, err := p.parseValue(); err != nil {
return err
} else {
*l = append(*l, n)
}
switch t := p.peek(); t.t {
case t_list_end:
p.next()
return nil
default:
return l.parse(p)
}
}
func (l *listNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%slist:\n", prefix)
for _, n := range *l {
if err := n.pretty(w, prefix+indent); err != nil {
return err
}
}
return nil
}
func (l *listNode) eval(ctx *context) (interface{}, error) {
out := make([]interface{}, 0, len(*l))
for _, n := range *l {
v, err := n.eval(ctx)
if err != nil {
return nil, err
}
out = append(out, v)
}
return out, nil
}
type objectNode map[string]node
func (o *objectNode) Type() nodeType {
return n_object
}
func (o *objectNode) parse(p *parser) error {
if p.peek().t == t_object_end {
p.next()
return nil
}
if err := p.ensureNext(t_name, "looking for object field name in parseObject"); err != nil {
return err
}
field_name := p.next().s
if err := p.ensureNext(t_object_separator, "looking for object separator in parseObject"); err != nil {
return err
}
p.next()
if n, err := p.parseValue(); err != nil {
return err
} else {
(*o)[field_name] = n
}
switch t := p.peek(); t.t {
case t_object_end:
p.next()
return nil
default:
return o.parse(p)
}
}
func (o *objectNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sobject:\n", prefix)
keys := make([]string, 0, len(*o))
for key := range *o {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
fmt.Fprintf(w, "%s%s:\n", prefix+indent, key)
err := (*o)[key].pretty(w, prefix+indent+indent)
if err != nil {
return err
}
}
return nil
}
func (o *objectNode) eval(ctx *context) (interface{}, error) {
out := make(map[string]interface{}, len(*o))
for name, node := range *o {
v, err := node.eval(ctx)
if err != nil {
return nil, err
}
out[name] = v
}
return out, nil
}
type variableNode struct {
name string
}
func (v *variableNode) Type() nodeType {
return n_variable
}
func (v *variableNode) parse(p *parser) error {
t := p.next()
if t.t != t_variable {
return fmt.Errorf("unexpected %s token when parsing variable", t.t)
}
v.name = t.s
return nil
}
func (v *variableNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%svariable:\n", prefix)
fmt.Fprintf(w, "%s%s\n", prefix+indent, v.name)
return nil
}
func (v *variableNode) eval(ctx *context) (interface{}, error) {
value, ok := ctx.get(v.name)
if !ok {
return nil, fmt.Errorf("undefined variable: %s", *v)
}
return value, nil
}
type boolNode bool
func (b *boolNode) Type() nodeType {
return n_bool
}
func (b *boolNode) parse(p *parser) error {
t := p.next()
if t.t != t_bool {
return fmt.Errorf("unexpected %s token while parsing bool", t.t)
}
switch t.s {
case "true":
*b = true
case "false":
default:
return fmt.Errorf("illegal lexeme for bool token: %s", t.s)
}
return nil
}
func (b *boolNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sbool:\n", prefix)
fmt.Fprintf(w, "%s%t\n", prefix+indent, *b)
return nil
}
func (b *boolNode) eval(ctx *context) (interface{}, error) {
return bool(*b), nil
}
type durationNode time.Duration
func (d *durationNode) Type() nodeType {
return n_duration
}
func (d *durationNode) parse(p *parser) error {
t := p.next()
if t.t != t_duration {
return fmt.Errorf("unexpected %s token while parsing duration", t.t)
}
v, err := time.ParseDuration(t.s)
if err != nil {
return fmt.Errorf("unable to parse duration: %s", err)
}
*d = durationNode(v)
return nil
}
func (d *durationNode) pretty(w io.Writer, prefix string) error {
fmt.Fprintf(w, "%sdur:\n", prefix)
fmt.Fprintf(w, "%s%s\n", prefix+indent, time.Duration(*d).String())
return nil
}
func (d *durationNode) eval(ctx *context) (interface{}, error) {
return time.Duration(*d), nil
}