From 6de4a22c888ca1dc8b9c901f24d6784efdda0c74 Mon Sep 17 00:00:00 2001 From: brettlangdon Date: Sat, 19 Sep 2015 14:02:38 -0400 Subject: [PATCH] cleanup ast directory --- ast/base.go | 19 ---------- ast/compoundstatement.go | 13 ------- ast/expressions.go | 16 ++++++++ ast/expressionstatement.go | 20 ---------- ast/listnode.go | 41 --------------------- ast/node.go | 6 --- ast/nodes.go | 67 ++++++++++++++++++++++++++++++++++ ast/simplestatement.go | 17 --------- ast/smallstatement.go | 23 ------------ ast/smallstatements.go | 32 ++++++++++++++++ ast/{fileinput.go => start.go} | 5 +-- ast/statement.go | 25 ------------- ast/statements.go | 43 ++++++++++++++++++++++ ast/testliststartexpr.go | 11 ------ ast/tests.go | 18 +++++++++ parser/parser.go | 36 ++++++++++++------ 16 files changed, 203 insertions(+), 189 deletions(-) delete mode 100644 ast/base.go delete mode 100644 ast/compoundstatement.go create mode 100644 ast/expressions.go delete mode 100644 ast/expressionstatement.go delete mode 100644 ast/listnode.go delete mode 100644 ast/node.go create mode 100644 ast/nodes.go delete mode 100644 ast/simplestatement.go delete mode 100644 ast/smallstatement.go create mode 100644 ast/smallstatements.go rename ast/{fileinput.go => start.go} (67%) delete mode 100644 ast/statement.go create mode 100644 ast/statements.go delete mode 100644 ast/testliststartexpr.go create mode 100644 ast/tests.go diff --git a/ast/base.go b/ast/base.go deleted file mode 100644 index dbcd00c..0000000 --- a/ast/base.go +++ /dev/null @@ -1,19 +0,0 @@ -package ast - -type BaseNode struct { - ID NodeID -} - -func (node *BaseNode) initBaseNode(id NodeID) { - node.ID = id -} - -func (node *BaseNode) Name() string { - return NodeNames[node.ID] -} - -func (node *BaseNode) Repr() []interface{} { - out := make([]interface{}, 0) - out = append(out, node.Name()) - return out -} diff --git a/ast/compoundstatement.go b/ast/compoundstatement.go deleted file mode 100644 index ea3cc46..0000000 --- a/ast/compoundstatement.go +++ /dev/null @@ -1,13 +0,0 @@ -package ast - -type CompoundStatement struct { - Statement -} - -func NewCompoundStatement() *CompoundStatement { - node := &CompoundStatement{} - node.initBaseNode(SIMPLE_STMT) - return node -} - -func (node *CompoundStatement) StatementNode() {} diff --git a/ast/expressions.go b/ast/expressions.go new file mode 100644 index 0000000..cd1edd2 --- /dev/null +++ b/ast/expressions.go @@ -0,0 +1,16 @@ +package ast + +type ExpressionNode interface { + Node + exprNode() +} + +type TestlistStarExpression struct { + ParentNode +} + +func NewTestListStarExpression() *TestlistStarExpression { + node := &TestlistStarExpression{} + node.initBaseNode(TESTLIST_STAR_EXPR) + return node +} diff --git a/ast/expressionstatement.go b/ast/expressionstatement.go deleted file mode 100644 index 723e669..0000000 --- a/ast/expressionstatement.go +++ /dev/null @@ -1,20 +0,0 @@ -package ast - -type ExpressionStatement struct { - BaseNode - Expression *TestlistStartExpr -} - -func NewExpressionStatement() *ExpressionStatement { - node := &ExpressionStatement{} - node.initBaseNode(EXPR_STMT) - return node -} - -func (node *ExpressionStatement) SmallStatementNode() {} - -func (node *ExpressionStatement) Repr() []interface{} { - out := node.BaseNode.Repr() - out = append(out, node.Expression.Repr()) - return out -} diff --git a/ast/listnode.go b/ast/listnode.go deleted file mode 100644 index 33290f3..0000000 --- a/ast/listnode.go +++ /dev/null @@ -1,41 +0,0 @@ -package ast - -import "github.com/brettlangdon/gython/token" - -type ListNode struct { - BaseNode - children []interface{} -} - -func (node *ListNode) initListNode() { - node.children = make([]interface{}, 0) -} - -func (node *ListNode) AppendToken(t *token.Token) { - node.children = append(node.children, t) -} - -func (node *ListNode) AppendNode(n Node) { - node.children = append(node.children, n) -} - -func (node *ListNode) Children() []interface{} { - return node.children -} - -func (node *ListNode) Length() int { - return len(node.children) -} - -func (node *ListNode) Repr() []interface{} { - out := node.BaseNode.Repr() - for _, child := range node.Children() { - switch child.(type) { - case Node: - out = append(out, child.(Node).Repr()) - default: - out = append(out, child) - } - } - return out -} diff --git a/ast/node.go b/ast/node.go deleted file mode 100644 index 6c42856..0000000 --- a/ast/node.go +++ /dev/null @@ -1,6 +0,0 @@ -package ast - -type Node interface { - Name() string - Repr() []interface{} -} diff --git a/ast/nodes.go b/ast/nodes.go new file mode 100644 index 0000000..04ccb12 --- /dev/null +++ b/ast/nodes.go @@ -0,0 +1,67 @@ +package ast + +import "github.com/brettlangdon/gython/token" + +type Node interface { + Name() string + Repr() []interface{} +} + +type TokenNode struct { + Token *token.Token +} + +func NewTokenNode(tok *token.Token) *TokenNode { + return &TokenNode{ + Token: tok, + } +} +func (node *TokenNode) Name() string { return token.TokenNames[node.Token.ID] } +func (node *TokenNode) Repr() []interface{} { + parts := make([]interface{}, 0) + parts = append(parts, node.Name()) + return append(parts, node.Token.Literal) +} + +type BaseNode struct { + ID NodeID + child Node +} + +func (node *BaseNode) initBaseNode(id NodeID) { node.ID = id } +func (node *BaseNode) Name() string { return NodeNames[node.ID] } +func (node *BaseNode) Repr() (parts []interface{}) { return append(parts, node.Name()) } + +type ParentNode struct { + BaseNode + child Node +} + +func (node *ParentNode) SetChild(n Node) { node.child = n } +func (node *ParentNode) Child() Node { return node.child } +func (node *ParentNode) Repr() (parts []interface{}) { + parts = node.BaseNode.Repr() + child := node.Child() + if child != nil { + parts = append(parts, child.Repr()) + } + return parts +} + +type ListNode struct { + BaseNode + children []Node +} + +func (node *ListNode) initListNode() { node.children = make([]Node, 0) } +func (node *ListNode) Length() int { return len(node.children) } +func (node *ListNode) Children() []Node { return node.children } +func (node *ListNode) Append(n Node) { node.children = append(node.children, n) } +func (node *ListNode) Repr() (parts []interface{}) { + parts = node.BaseNode.Repr() + children := node.Children() + for _, child := range children { + parts = append(parts, child.Repr()) + } + return parts +} diff --git a/ast/simplestatement.go b/ast/simplestatement.go deleted file mode 100644 index c5aea0c..0000000 --- a/ast/simplestatement.go +++ /dev/null @@ -1,17 +0,0 @@ -package ast - -type SimpleStatement struct { - ListNode -} - -func NewSimpleStatement() *SimpleStatement { - node := &SimpleStatement{} - node.initBaseNode(SIMPLE_STMT) - return node -} - -func (node *SimpleStatement) StatementNode() {} - -func (node *SimpleStatement) AppendNode(n *SmallStatement) { - node.ListNode.AppendNode(n) -} diff --git a/ast/smallstatement.go b/ast/smallstatement.go deleted file mode 100644 index 0bbdad2..0000000 --- a/ast/smallstatement.go +++ /dev/null @@ -1,23 +0,0 @@ -package ast - -type SmallStatementNode interface { - Node - SmallStatementNode() -} - -type SmallStatement struct { - BaseNode - Statement SmallStatementNode -} - -func NewSmallStatement() *SmallStatement { - node := &SmallStatement{} - node.initBaseNode(SMALL_STMT) - return node -} - -func (node *SmallStatement) Repr() []interface{} { - out := node.BaseNode.Repr() - out = append(out, node.Statement.Repr()) - return out -} diff --git a/ast/smallstatements.go b/ast/smallstatements.go new file mode 100644 index 0000000..a7156e4 --- /dev/null +++ b/ast/smallstatements.go @@ -0,0 +1,32 @@ +package ast + +type SmallStatementNode interface { + Node + smallStmtNode() +} + +type SmallStatement struct { + ParentNode +} + +func NewSmallStatement() *SmallStatement { + node := &SmallStatement{} + node.initBaseNode(SMALL_STMT) + return node +} + +func (node *SmallStatement) SetChild(n SmallStatementNode) { node.ParentNode.SetChild(n) } + +type ExpressionStatement struct { + ParentNode + Expression *TestlistStarExpression +} + +func NewExpressionStatement() *ExpressionStatement { + node := &ExpressionStatement{} + node.initBaseNode(EXPR_STMT) + return node +} + +func (node *ExpressionStatement) smallStmtNode() {} +func (node *ExpressionStatement) SetChild(n *TestlistStarExpression) { node.ParentNode.SetChild(n) } diff --git a/ast/fileinput.go b/ast/start.go similarity index 67% rename from ast/fileinput.go rename to ast/start.go index e2ce5ef..709ceee 100644 --- a/ast/fileinput.go +++ b/ast/start.go @@ -10,6 +10,5 @@ func NewFileInput() *FileInput { node.initListNode() return node } -func (node *FileInput) AppendNode(n StatementNode) { - node.ListNode.AppendNode(n) -} + +func (node *FileInput) Append(n *Statement) { node.ListNode.Append(n) } diff --git a/ast/statement.go b/ast/statement.go deleted file mode 100644 index 013ee99..0000000 --- a/ast/statement.go +++ /dev/null @@ -1,25 +0,0 @@ -package ast - -type StatementNode interface { - Node - StatementNode() -} - -type Statement struct { - BaseNode - Statement StatementNode -} - -func NewStatement() *Statement { - node := &Statement{} - node.initBaseNode(STMT) - return node -} - -func (node *Statement) StatementNode() {} - -func (node *Statement) Repr() []interface{} { - out := node.BaseNode.Repr() - out = append(out, node.Statement.Repr()) - return out -} diff --git a/ast/statements.go b/ast/statements.go new file mode 100644 index 0000000..51a103f --- /dev/null +++ b/ast/statements.go @@ -0,0 +1,43 @@ +package ast + +type StatementNode interface { + Node + stmtNode() +} + +type Statement struct { + ParentNode +} + +func NewStatement() *Statement { + node := &Statement{} + node.initBaseNode(STMT) + return node +} + +func (node *Statement) SetChild(n StatementNode) { node.ParentNode.SetChild(n) } + +type SimpleStatement struct { + ListNode +} + +func NewSimpleStatement() *SimpleStatement { + node := &SimpleStatement{} + node.initBaseNode(SIMPLE_STMT) + node.initListNode() + return node +} + +func (node *SimpleStatement) stmtNode() {} +func (node *SimpleStatement) Append(n *SmallStatement) { node.ListNode.Append(n) } + +type CompoundStatement struct { + BaseNode +} + +func NewCompoundStatement() *CompoundStatement { + node := &CompoundStatement{} + node.initBaseNode(COMPOUND_STMT) + return node +} +func (node *CompoundStatement) stmtNode() {} diff --git a/ast/testliststartexpr.go b/ast/testliststartexpr.go deleted file mode 100644 index cd3f462..0000000 --- a/ast/testliststartexpr.go +++ /dev/null @@ -1,11 +0,0 @@ -package ast - -type TestlistStartExpr struct { - BaseNode -} - -func NewTestListStartExpr() *TestlistStartExpr { - node := &TestlistStartExpr{} - node.initBaseNode(TESTLIST_STAR_EXPR) - return node -} diff --git a/ast/tests.go b/ast/tests.go new file mode 100644 index 0000000..a3a5ba0 --- /dev/null +++ b/ast/tests.go @@ -0,0 +1,18 @@ +package ast + +type TestNode interface { + Node + test() +} + +type Test struct { + ParentNode +} + +func NewTest() *Test { + node := &Test{} + node.initBaseNode(TEST) + return node +} + +func (node *Test) SetChild(n TestNode) { node.ParentNode.SetChild(n) } diff --git a/parser/parser.go b/parser/parser.go index 7365427..8fa0795 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -50,21 +50,34 @@ func (parser *Parser) parseCompoundStatement() *ast.CompoundStatement { return compoundStmt } +// test: or_test ['if' or_test 'else' test] | lambdef +func (parser *Parser) parseTest() *ast.Test { + test := ast.NewTest() + return test +} + // testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -func (parser *Parser) parseTestlistStartExpr() *ast.TestlistStartExpr { - testlistStartExpr := ast.NewTestListStartExpr() - return testlistStartExpr +func (parser *Parser) parseTestlistStarExpression() *ast.TestlistStarExpression { + testlistStarExpression := ast.NewTestListStarExpression() + + var expr ast.Node + expr = parser.parseTest() + if expr == nil { + return nil + } + testlistStarExpression.SetChild(expr) + return testlistStarExpression } // expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | // ('=' (yield_expr|testlist_star_expr))*) func (parser *Parser) parseExpressionStatement() *ast.ExpressionStatement { exprStmt := ast.NewExpressionStatement() - testlistStartExpr := parser.parseTestlistStartExpr() - if testlistStartExpr == nil { + testlistStarExpression := parser.parseTestlistStarExpression() + if testlistStarExpression == nil { return nil } - exprStmt.Expression = testlistStartExpr + exprStmt.SetChild(testlistStarExpression) return exprStmt } @@ -76,7 +89,7 @@ func (parser *Parser) parseSmallStatment() *ast.SmallStatement { var stmt ast.SmallStatementNode stmt = parser.parseExpressionStatement() if stmt != nil { - smallStmt.Statement = stmt + smallStmt.SetChild(stmt) } if stmt == nil { @@ -93,7 +106,7 @@ func (parser *Parser) parseSimpleStatement() *ast.SimpleStatement { if smallStmt == nil { break } - simpleStmt.AppendNode(smallStmt) + simpleStmt.Append(smallStmt) next := parser.nextToken() if next.ID != token.SEMI { parser.unreadToken(next) @@ -122,7 +135,7 @@ func (parser *Parser) parseStatement() *ast.Statement { } stmt := ast.NewStatement() - stmt.Statement = next + stmt.SetChild(next) return stmt } @@ -132,7 +145,8 @@ func (parser *Parser) parseFileInput() *ast.FileInput { for parser.tokenizer.State() == errorcode.E_OK { next := parser.nextToken() if next.ID == token.NEWLINE { - root.AppendToken(next) + // root.Append(ast.NewTokenNode(next)) + continue } else if next.ID == token.ENDMARKER { // Unread, so we can read in the expected value later parser.unreadToken(next) @@ -143,7 +157,7 @@ func (parser *Parser) parseFileInput() *ast.FileInput { if stmt == nil { break } - root.AppendNode(stmt) + root.Append(stmt) break } }