|
@@ -6,196 +6,294 @@ import (
|
|
|
"strings"
|
|
|
)
|
|
|
|
|
|
-/*
|
|
|
-type AstKind int
|
|
|
-
|
|
|
+type AstBasicMetaKind string
|
|
|
+
|
|
|
+type AstMetaKindNone AstBasicMetaKind
|
|
|
+type AstMetaKindProgram AstBasicMetaKind
|
|
|
+type AstMetaKindStatements AstBasicMetaKind
|
|
|
+type AstMetaKindStatement AstBasicMetaKind
|
|
|
+type AstMetaKindSet AstBasicMetaKind
|
|
|
+type AstMetaKindGet AstBasicMetaKind
|
|
|
+type AstMetaKindTarget AstBasicMetaKind
|
|
|
+type AstMetaKindCommand AstBasicMetaKind
|
|
|
+type AstMetaKindArguments AstBasicMetaKind
|
|
|
+type AstMetaKindArgument AstBasicMetaKind
|
|
|
+type AstMetaKindExpression AstBasicMetaKind
|
|
|
+type AstMetaKindBlock AstBasicMetaKind
|
|
|
+type AstMetaKindParenthesis AstBasicMetaKind
|
|
|
+type AstMetaKindList AstBasicMetaKind
|
|
|
+type AstMetaKindCapture AstBasicMetaKind
|
|
|
+type AstMetaKindWordValue AstBasicMetaKind
|
|
|
+type AstMetaKindWord AstBasicMetaKind
|
|
|
+type AstMetaKindType AstBasicMetaKind
|
|
|
+type AstMetaKindValue AstBasicMetaKind
|
|
|
+type AstMetaKindEnd AstBasicMetaKind
|
|
|
+type AstMetaKindError AstBasicMetaKind
|
|
|
+
|
|
|
+/** The actual types are defined as constants, the meta types are used to be able to have different behavior for them.*/
|
|
|
const (
|
|
|
- AstKindProgram = AstKind(iota)
|
|
|
- AstKindStatements
|
|
|
- AstKindStatement
|
|
|
- AstKindSet
|
|
|
- AstKindGet
|
|
|
- AstKindTarget
|
|
|
- AstKindCommand
|
|
|
- AstKindArguments
|
|
|
- AstKindArgument
|
|
|
- AstKindExpression
|
|
|
- AstKindBlock
|
|
|
- AstKindParenthesis
|
|
|
- AstKindList
|
|
|
- AstKindCapture
|
|
|
- AstKindWordValue
|
|
|
- AstKindWord
|
|
|
- AstKindType
|
|
|
- AstKindValue
|
|
|
- AstKindEnd
|
|
|
- AstKindError
|
|
|
+ AstKindNone = AstMetaKindNone("None")
|
|
|
+ AstKindProgram = AstMetaKindProgram("Program")
|
|
|
+ AstKindStatements = AstMetaKindStatements("Statements")
|
|
|
+ AstKindStatement = AstMetaKindStatement("Statement")
|
|
|
+ AstKindSet = AstMetaKindSet("Set")
|
|
|
+ AstKindGet = AstMetaKindGet("Get")
|
|
|
+ AstKindTarget = AstMetaKindTarget("Target")
|
|
|
+ AstKindCommand = AstMetaKindCommand("Command")
|
|
|
+ AstKindArguments = AstMetaKindArguments("Arguments")
|
|
|
+ AstKindArgument = AstMetaKindArgument("Argument")
|
|
|
+ AstKindExpression = AstMetaKindExpression("Expression")
|
|
|
+ AstKindBlock = AstMetaKindBlock("Block")
|
|
|
+ AstKindParenthesis = AstMetaKindParenthesis("Parenthesis")
|
|
|
+ AstKindList = AstMetaKindList("List")
|
|
|
+ AstKindCapture = AstMetaKindCapture("Capture")
|
|
|
+ AstKindWordValue = AstMetaKindWordValue("WordValue")
|
|
|
+ AstKindWord = AstMetaKindWord("Word")
|
|
|
+ AstKindType = AstMetaKindType("Type")
|
|
|
+ AstKindValue = AstMetaKindValue("Value")
|
|
|
+ AstKindEnd = AstMetaKindEnd("End")
|
|
|
+ AstKindError = AstMetaKindError("Error")
|
|
|
)
|
|
|
-*/
|
|
|
|
|
|
-/*
|
|
|
-func (BasicAst Ast) String() string {
|
|
|
- switch astkind {
|
|
|
- case AstKindProgram:
|
|
|
- return "AstKindProgram"
|
|
|
- case AstKindStatements:
|
|
|
- return "AstKindStatements"
|
|
|
- case AstKindStatement:
|
|
|
- return "AstKindStatement"
|
|
|
- case AstKindSet:
|
|
|
- return "AstKindSet"
|
|
|
- case AstKindGet:
|
|
|
- return "AstKindGet"
|
|
|
- case AstKindTarget:
|
|
|
- return "AstKindTarget"
|
|
|
- case AstKindCommand:
|
|
|
- return "AstKindCommand"
|
|
|
- case AstKindArguments:
|
|
|
- return "AstKindArguments"
|
|
|
- case AstKindArgument:
|
|
|
- return "AstKindArgument"
|
|
|
- case AstKindExpression:
|
|
|
- return "AstKindExpression"
|
|
|
- case AstKindBlock:
|
|
|
- return "AstKindBlock"
|
|
|
- case AstKindParenthesis:
|
|
|
- return "AstKindParenthesis"
|
|
|
- case AstKindList:
|
|
|
- return "AstKindList"
|
|
|
- case AstKindCapture:
|
|
|
- return "AstKindCapture"
|
|
|
- case AstKindWordValue:
|
|
|
- return "AstKindWordValue"
|
|
|
- case AstKindWord:
|
|
|
- return "AstKindWord"
|
|
|
- case AstKindType:
|
|
|
- return "AstKindType"
|
|
|
- case AstKindValue:
|
|
|
- return "AstKindValue"
|
|
|
- case AstKindEnd:
|
|
|
- return "AstKindEnd"
|
|
|
- case AstKindError:
|
|
|
- return "AstKindError"
|
|
|
- default:
|
|
|
- return "Unknown AstKind"
|
|
|
+func (astkind AstBasicMetaKind) String() string {
|
|
|
+ return string(astkind)
|
|
|
+}
|
|
|
+
|
|
|
+func (astkind AstBasicMetaKind) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+
|
|
|
+func (astkind AstMetaKindNone) String() string { return "AstNone " }
|
|
|
+func (astkind AstMetaKindProgram) String() string { return "AstProgram " }
|
|
|
+func (astkind AstMetaKindStatements) String() string { return "AstStatements " }
|
|
|
+func (astkind AstMetaKindStatement) String() string { return "AstStatement " }
|
|
|
+func (astkind AstMetaKindSet) String() string { return "AstSet " }
|
|
|
+func (astkind AstMetaKindGet) String() string { return "AstGet " }
|
|
|
+func (astkind AstMetaKindTarget) String() string { return "AstTarget " }
|
|
|
+func (astkind AstMetaKindCommand) String() string { return "AstCommand " }
|
|
|
+func (astkind AstMetaKindArguments) String() string { return "AstArguments " }
|
|
|
+func (astkind AstMetaKindArgument) String() string { return "AstArgument " }
|
|
|
+func (astkind AstMetaKindExpression) String() string { return "AstExpression " }
|
|
|
+func (astkind AstMetaKindBlock) String() string { return "AstBlock " }
|
|
|
+func (astkind AstMetaKindParenthesis) String() string { return "AstParenthesis" }
|
|
|
+func (astkind AstMetaKindList) String() string { return "AstList " }
|
|
|
+func (astkind AstMetaKindCapture) String() string { return "AstCapture " }
|
|
|
+func (astkind AstMetaKindWordValue) String() string { return "AstWordValue " }
|
|
|
+func (astkind AstMetaKindWord) String() string { return "AstWord " }
|
|
|
+func (astkind AstMetaKindType) String() string { return "AstType " }
|
|
|
+func (astkind AstMetaKindValue) String() string { return "AstValue " }
|
|
|
+func (astkind AstMetaKindEnd) String() string { return "AstEnd " }
|
|
|
+func (astkind AstMetaKindError) String() string { return "AstError " }
|
|
|
+
|
|
|
+func (astkind AstMetaKindNone) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+
|
|
|
+func (astkind AstMetaKindProgram) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ res := EmptyValueArray()
|
|
|
+ for _, child := range ast.Children() {
|
|
|
+ res = append(res, child.Run(vm, val)...)
|
|
|
}
|
|
|
+ return res
|
|
|
}
|
|
|
-*/
|
|
|
|
|
|
-type Ast interface {
|
|
|
- Parent() Ast
|
|
|
- Children() []Ast
|
|
|
+func (astkind AstMetaKindStatements) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindStatement) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindSet) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindGet) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindTarget) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindCommand) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindArguments) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindArgument) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindExpression) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindBlock) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindParenthesis) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindList) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindCapture) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindWordValue) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindWord) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindType) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindValue) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
+func (astkind AstMetaKindEnd) Run(vm *VM, ast Ast, val []Value) []Value { return EmptyValueArray() }
|
|
|
+func (astkind AstMetaKindError) Run(vm *VM, ast Ast, val []Value) []Value {
|
|
|
+ return EmptyValueArray()
|
|
|
+}
|
|
|
|
|
|
- Run(vm *VM, val ListValue) ListValue
|
|
|
+type AstKind interface {
|
|
|
String() string
|
|
|
- Token() Token
|
|
|
- /* AppendChild(child Ast) Ast
|
|
|
- NewChild(kind AstKind, token Token) Ast
|
|
|
- */
|
|
|
+ Run(vm *VM, ast Ast, val []Value) []Value
|
|
|
+}
|
|
|
|
|
|
- /* Make(parent Ast, token Token) Ast */
|
|
|
+/*
|
|
|
+func (Ast Ast) String() string {
|
|
|
+ switch astkind {
|
|
|
+ case AstMetaKindProgram:
|
|
|
+ return "AstMetaKindProgram"
|
|
|
+ case AstMetaKindStatements:
|
|
|
+ return "AstMetaKindStatements"
|
|
|
+ case AstMetaKindStatement:
|
|
|
+ return "AstMetaKindStatement"
|
|
|
+ case AstMetaKindSet:
|
|
|
+ return "AstMetaKindSet"
|
|
|
+ case AstMetaKindGet:
|
|
|
+ return "AstMetaKindGet"
|
|
|
+ case AstMetaKindTarget:
|
|
|
+ return "AstMetaKindTarget"
|
|
|
+ case AstMetaKindCommand:
|
|
|
+ return "AstMetaKindCommand"
|
|
|
+ case AstMetaKindArguments:
|
|
|
+ return "AstMetaKindArguments"
|
|
|
+ case AstMetaKindArgument:
|
|
|
+ return "AstMetaKindArgument"
|
|
|
+ case AstMetaKindExpression:
|
|
|
+ return "AstMetaKindExpression"
|
|
|
+ case AstMetaKindBlock:
|
|
|
+ return "AstMetaKindBlock"
|
|
|
+ case AstMetaKindParenthesis:
|
|
|
+ return "AstMetaKindParenthesis"
|
|
|
+ case AstMetaKindList:
|
|
|
+ return "AstMetaKindList"
|
|
|
+ case AstMetaKindCapture:
|
|
|
+ return "AstMetaKindCapture"
|
|
|
+ case AstMetaKindWordValue:
|
|
|
+ return "AstMetaKindWordValue"
|
|
|
+ case AstMetaKindWord:
|
|
|
+ return "AstMetaKindWord"
|
|
|
+ case AstMetaKindType:
|
|
|
+ return "AstMetaKindType"
|
|
|
+ case AstMetaKindValue:
|
|
|
+ return "AstMetaKindValue"
|
|
|
+ case AstMetaKindEnd:
|
|
|
+ return "AstMetaKindEnd"
|
|
|
+ case AstMetaKindError:
|
|
|
+ return "AstMetaKindError"
|
|
|
+ default:
|
|
|
+ return "Unknown AstMetaKind"
|
|
|
+ }
|
|
|
}
|
|
|
+*/
|
|
|
|
|
|
/*
|
|
|
func AstAppendChild(parent Ast, child Ast) Ast {
|
|
|
- basicParent := parent.(*BasicAst)
|
|
|
+ basicParent := parent.(*Ast)
|
|
|
return basicParent.AppendChild(child)
|
|
|
}
|
|
|
|
|
|
-func AstNewChild(parent Ast, kind AstKind, token Token) Ast {
|
|
|
- basicParent := parent.(*BasicAst)
|
|
|
+func AstNewChild(parent Ast, kind AstMetaKind, token Token) Ast {
|
|
|
+ basicParent := parent.(*Ast)
|
|
|
return basicParent.NewChild(kind, token)
|
|
|
}
|
|
|
*/
|
|
|
|
|
|
/* AST node kind */
|
|
|
-type BasicAst struct {
|
|
|
- parent Ast
|
|
|
+type Ast struct {
|
|
|
+ AstKind
|
|
|
+ parent *Ast
|
|
|
children []Ast
|
|
|
token Token
|
|
|
}
|
|
|
|
|
|
-var _ Ast = &BasicAst{}
|
|
|
-
|
|
|
-func NewAst(kind AstKind, parent Ast, children []Ast, token Token) Ast {
|
|
|
- ast := kind(parent, children, token)
|
|
|
- return ast
|
|
|
+func NewAst(kind AstKind, parent *Ast, children []Ast, token Token) Ast {
|
|
|
+ return Ast{kind, parent, children, token}
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
-func (ast *BasicAst) AppendChild(child Ast) Ast {
|
|
|
+func (ast *Ast) AppendChild(child Ast) Ast {
|
|
|
ast.children = append(ast.children, child)
|
|
|
return child
|
|
|
}
|
|
|
|
|
|
-func (ast *BasicAst) NewChild(kind AstKind, token Token) Ast {
|
|
|
- child := NewAst(kind, ast, token)
|
|
|
+func (ast *Ast) NewChild(kind AstKind, token Token) Ast {
|
|
|
+ child := NewAst(kind, ast, make([]Ast, 0), token)
|
|
|
ast.AppendChild(child)
|
|
|
return child
|
|
|
}
|
|
|
-*/
|
|
|
|
|
|
-func (ast BasicAst) IsError() bool {
|
|
|
- return false
|
|
|
+func (ast Ast) IsKind(astkind AstKind) bool {
|
|
|
+ return ast.AstKind == astkind
|
|
|
+}
|
|
|
+
|
|
|
+func (ast Ast) IsError() bool {
|
|
|
+ return ast.AstKind == AstKindError
|
|
|
}
|
|
|
|
|
|
-func (ast AstError) IsError() bool {
|
|
|
- return true
|
|
|
+func (ast Ast) IsNone() bool {
|
|
|
+ return ast.AstKind == AstKindNone
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Token() Token {
|
|
|
+func (ast Ast) Token() Token {
|
|
|
return ast.token
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Parent() Ast {
|
|
|
+func (ast Ast) Parent() *Ast {
|
|
|
return ast.parent
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Children() []Ast {
|
|
|
+func (ast Ast) Children() []Ast {
|
|
|
return ast.children
|
|
|
}
|
|
|
|
|
|
-func (ast *BasicAst) SetParent(parent Ast) {
|
|
|
+func (ast Ast) Kind() AstKind {
|
|
|
+ return ast.AstKind
|
|
|
+}
|
|
|
+
|
|
|
+func (ast *Ast) SetParent(parent *Ast) {
|
|
|
ast.parent = parent
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Child(index int) Ast {
|
|
|
+func (ast Ast) Child(index int) *Ast {
|
|
|
count := ast.CountChildren()
|
|
|
if index < 0 || index > count {
|
|
|
return nil
|
|
|
}
|
|
|
- return ast.children[index]
|
|
|
+ return &ast.children[index]
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Run(vm *VM, val ListValue) ListValue {
|
|
|
- panic("Please implement Run for this node.")
|
|
|
- return ListValue{}
|
|
|
+func (ast Ast) Run(vm *VM, val []Value) []Value {
|
|
|
+ return ast.AstKind.Run(vm, ast, val)
|
|
|
}
|
|
|
|
|
|
-func (ast *BasicAst) Walk(walker func(node Ast) Ast) Ast {
|
|
|
+func (ast *Ast) Walk(walker func(node *Ast) *Ast) *Ast {
|
|
|
if found := walker(ast); found != nil {
|
|
|
return found
|
|
|
}
|
|
|
for _, child := range ast.children {
|
|
|
- if found := child.(*BasicAst).Walk(walker); found != nil {
|
|
|
+ if found := child.Walk(walker); found != nil {
|
|
|
return found
|
|
|
}
|
|
|
}
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) String() string {
|
|
|
- if ast.Token == nil {
|
|
|
- return fmt.Sprintf("BasicAst %s nil", ast.token.String())
|
|
|
- }
|
|
|
- return fmt.Sprintf("BasicAst %v", ast.token.String())
|
|
|
+func (ast Ast) String() string {
|
|
|
+ return fmt.Sprintf("Ast %s: %s", ast.AstKind.String(), ast.token.String())
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Display() {
|
|
|
- ast.Walk(func(node Ast) Ast {
|
|
|
- bast := node.(*BasicAst)
|
|
|
- depth := bast.Depth()
|
|
|
- fmt.Printf(strings.Repeat("--", depth))
|
|
|
+func (ast Ast) Display() {
|
|
|
+ ast.Walk(func(node *Ast) *Ast {
|
|
|
+ depth := ast.Depth()
|
|
|
+ fmt.Printf("%s", strings.Repeat("--", depth))
|
|
|
if node != nil {
|
|
|
fmt.Printf("Ast: %s\n", node.String())
|
|
|
} else {
|
|
@@ -205,7 +303,7 @@ func (ast BasicAst) Display() {
|
|
|
})
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Depth() int {
|
|
|
+func (ast Ast) Depth() int {
|
|
|
var depth int = 0
|
|
|
parent := ast.parent
|
|
|
for parent != nil {
|
|
@@ -215,18 +313,17 @@ func (ast BasicAst) Depth() int {
|
|
|
return depth
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) CountChildren() int {
|
|
|
+func (ast Ast) CountChildren() int {
|
|
|
return len(ast.children)
|
|
|
}
|
|
|
|
|
|
func AstIsError(ast Ast) bool {
|
|
|
- _, isError := ast.(*AstError)
|
|
|
- return isError
|
|
|
+ return ast.IsError()
|
|
|
}
|
|
|
|
|
|
-func (ast BasicAst) Errors() []Ast {
|
|
|
- res := make([]Ast, 0)
|
|
|
- ast.Walk(func(node Ast) Ast {
|
|
|
+func (ast Ast) Errors() []*Ast {
|
|
|
+ res := make([]*Ast, 0)
|
|
|
+ ast.Walk(func(node *Ast) *Ast {
|
|
|
if node != nil && ast.IsError() {
|
|
|
res = append(res, node)
|
|
|
}
|
|
@@ -239,60 +336,51 @@ func EmptyAstArray() []Ast {
|
|
|
return make([]Ast, 0)
|
|
|
}
|
|
|
|
|
|
-type AstProgram struct{ BasicAst }
|
|
|
-type AstStatements struct{ BasicAst }
|
|
|
-type AstStatement struct{ BasicAst }
|
|
|
-type AstSet struct{ BasicAst }
|
|
|
-type AstGet struct{ BasicAst }
|
|
|
-type AstTarget struct{ BasicAst }
|
|
|
-type AstCommand struct{ BasicAst }
|
|
|
-type AstArguments struct{ BasicAst }
|
|
|
-type AstArgument struct{ BasicAst }
|
|
|
-type AstExpression struct{ BasicAst }
|
|
|
-type AstBlock struct{ BasicAst }
|
|
|
-type AstParenthesis struct{ BasicAst }
|
|
|
-type AstList struct{ BasicAst }
|
|
|
-type AstCapture struct{ BasicAst }
|
|
|
-type AstWordValue struct{ BasicAst }
|
|
|
-type AstWord struct{ BasicAst }
|
|
|
-type AstType struct{ BasicAst }
|
|
|
-type AstValue struct{ BasicAst }
|
|
|
-type AstEnd struct{ BasicAst }
|
|
|
-type AstError struct{ BasicAst }
|
|
|
-
|
|
|
-func (ast AstProgram) String() string { return "AstProgram " }
|
|
|
-func (ast AstStatements) String() string { return "AstStatements " }
|
|
|
-func (ast AstStatement) String() string { return "AstStatement " }
|
|
|
-func (ast AstSet) String() string { return "AstSet " }
|
|
|
-func (ast AstGet) String() string { return "AstGet " }
|
|
|
-func (ast AstTarget) String() string { return "AstTarget " }
|
|
|
-func (ast AstCommand) String() string { return "AstCommand " }
|
|
|
-func (ast AstArguments) String() string { return "AstArguments " }
|
|
|
-func (ast AstArgument) String() string { return "AstArgument " }
|
|
|
-func (ast AstExpression) String() string { return "AstExpression " }
|
|
|
-func (ast AstBlock) String() string { return "AstBlock " }
|
|
|
-func (ast AstParenthesis) String() string { return "AstParenthesis" }
|
|
|
-func (ast AstList) String() string { return "AstList " }
|
|
|
-func (ast AstCapture) String() string { return "AstCapture " }
|
|
|
-func (ast AstWordValue) String() string { return "AstWordValue " }
|
|
|
-func (ast AstWord) String() string { return "AstWord " }
|
|
|
-func (ast AstType) String() string { return "AstType " }
|
|
|
-func (ast AstValue) String() string { return "AstValue " }
|
|
|
-func (ast AstEnd) String() string { return "AstEnd " }
|
|
|
-func (ast AstError) String() string { return "AstError " }
|
|
|
-
|
|
|
-var _ Ast = AstProgram{}
|
|
|
-
|
|
|
-func NewBasicAst(parent Ast, children []Ast, token Token) BasicAst {
|
|
|
- return BasicAst{parent, children, token}
|
|
|
+func NewEmptyAst(astkind AstKind) Ast {
|
|
|
+ return NewAst(astkind, nil, EmptyAstArray(), NoToken())
|
|
|
+}
|
|
|
+
|
|
|
+func NewAstNone() Ast {
|
|
|
+ return NewEmptyAst(AstKindNone)
|
|
|
}
|
|
|
|
|
|
+func NewAstWithToken(astkind AstKind, token Token) Ast {
|
|
|
+ return NewAst(astkind, nil, EmptyAstArray(), token)
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+type AstProgram struct{ Ast }
|
|
|
+type AstStatements struct{ Ast }
|
|
|
+type AstStatement struct{ Ast }
|
|
|
+type AstSet struct{ Ast }
|
|
|
+type AstGet struct{ Ast }
|
|
|
+type AstTarget struct{ Ast }
|
|
|
+type AstCommand struct{ Ast }
|
|
|
+type AstArguments struct{ Ast }
|
|
|
+type AstArgument struct{ Ast }
|
|
|
+type AstExpression struct{ Ast }
|
|
|
+type AstBlock struct{ Ast }
|
|
|
+type AstParenthesis struct{ Ast }
|
|
|
+type AstList struct{ Ast }
|
|
|
+type AstCapture struct{ Ast }
|
|
|
+type AstWordValue struct{ Ast }
|
|
|
+type AstWord struct{ Ast }
|
|
|
+type AstType struct{ Ast }
|
|
|
+type AstValue struct{ Ast }
|
|
|
+type AstEnd struct{ Ast }
|
|
|
+type AstError struct{ Ast }
|
|
|
+*/
|
|
|
+
|
|
|
+var _ Ast = Ast{}
|
|
|
+
|
|
|
/* The kind of an AST is also it's constructor function. This is so deep I'm almost
|
|
|
getting scared. :) */
|
|
|
// The type is defined as a constructor
|
|
|
-type AstKind func(parent Ast, children []Ast, token Token) Ast
|
|
|
|
|
|
-type AstKind2 interface {
|
|
|
+/*
|
|
|
+type AstMetaKind func(parent Ast, children []Ast, token Token) Ast
|
|
|
+
|
|
|
+type AstMetaKind2 interface {
|
|
|
New(parent Ast, children []Ast, token Token) Ast
|
|
|
}
|
|
|
|
|
@@ -306,66 +394,67 @@ func NewAstProgram(parent Ast, children []Ast, token Token) Ast {
|
|
|
return AstProgram{NewBasicAst(parent, children, token)}
|
|
|
}
|
|
|
|
|
|
-var AstKindBasic = AstKind(func(parent Ast, children []Ast, token Token) Ast { return NewBasicAst(parent, children, token) })
|
|
|
+var AstMetaKindBasic = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast { return NewBasicAst(parent, children, token) })
|
|
|
|
|
|
-var AstKindProgram = AstKind(NewAstProgram)
|
|
|
-var AstKindProgram2 = AstKind2(AstTypeProgramImp{})
|
|
|
+var AstMetaKindProgram = AstMetaKind(NewAstProgram)
|
|
|
+var AstMetaKindProgram2 = AstMetaKind2(AstTypeProgramImp{})
|
|
|
|
|
|
-var AstKindStatements = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindStatements = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstStatements{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
|
|
|
-var AstKindStatement = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindStatement = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstStatement{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindSet = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindSet = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstSet{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindGet = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindGet = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstGet{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindTarget = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindTarget = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstTarget{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindCommand = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindCommand = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstCommand{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindArguments = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindArguments = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstArguments{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindArgument = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindArgument = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstArgument{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindExpression = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindExpression = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstExpression{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindBlock = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindBlock = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstBlock{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindParenthesis = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindParenthesis = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstParenthesis{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindList = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindList = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstList{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindCapture = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindCapture = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstCapture{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindWordValue = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindWordValue = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstWordValue{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindWord = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindWord = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstWord{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindType = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindType = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstType{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindValue = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindValue = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstValue{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindEnd = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindEnd = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstEnd{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
-var AstKindError = AstKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
+var AstMetaKindError = AstMetaKind(func(parent Ast, children []Ast, token Token) Ast {
|
|
|
return &AstError{NewBasicAst(parent, children, token)}
|
|
|
})
|
|
|
+*/
|