func (p *parser) parseTypeName(n *parse.Node) ast.Expr {
n = n.Child(0)
if n.Rule() == identifier {
return p.parseIdent(n)
}
return p.parseQualifiedIdent(n)
}
func (p *parser) parseGoExpr(n *parse.Node) ast.Expr {
n = n.Child(0).Child(0)
switch n.Rule() {
case expr:
return p.parseExpr(n)
case type_:
return p.parseType(n)
}
return nil
}
func (p *parser) parseResults(n *parse.Node, scope *ast.Scope) *ast.FieldList {
n = n.Child(0)
switch n.Rule() {
case parameters:
return p.parseParams(n, scope)
case type_:
return &ast.FieldList{List: []*ast.Field{{Type: p.parseType(n)}}}
}
return nil
}
func (p *parser) parseType(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case typeName:
return p.parseTypeName(n)
case typeLit:
return p.parseTypeLit(n)
}
return p.parseType(n.Child(1))
}
func (p *parser) parseValue(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case expr:
return p.parseExpr(n)
case literalValue:
}
fmt.Println("parseValue", n)
return nil
}
func (p *parser) parseSwitchStmt(n *parse.Node) ast.Stmt {
p.openScope()
n = n.Child(0)
switch n.Rule() {
case exprSwitchStmt:
return p.parseExprSwitchStmt(n)
case typeSwitchStmt:
return p.parseTypeSwitchStmt(n)
}
p.closeScope()
return nil
}
func (p *parser) parseDecl(n *parse.Node) ast.Decl {
n = n.Child(0)
switch n.Rule() {
case constDecl:
return p.parseConstDecl(n)
case typeDecl:
return p.parseTypeDecl(n)
case varDecl:
return p.parseVarDecl(n)
}
return nil
}
func (p *parser) parseTopLevelDecl(n *parse.Node) ast.Decl {
n = n.Child(0)
switch n.Rule() {
case decl:
return p.parseDecl(n)
case funcDecl:
return p.parseFuncDecl(n)
case methodDecl:
return p.parseMethodDecl(n)
}
return nil
}
func (p *parser) parseLiteral(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case basicLit:
return p.parseBasicLit(n.Child(0))
case compositeLit:
return p.parseCompositeLit(n)
case funcLit:
return p.parseFuncLit(n)
}
return nil
}
func (p *parser) parseOperand(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case literal:
return p.parseLiteral(n)
case operandName:
return p.parseIdent(n)
default:
return p.parseExpr(n.Child(1))
}
return nil
}
func (p *parser) parseElse(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
switch n.Rule() {
case ifStmt:
return p.parseIfStmt(n)
case block:
return p.parseBlock(n, p.topScope)
}
return nil
}
func (p *parser) parseSimpleStmt(n *parse.Node) ast.Stmt {
n = n.Child(0)
switch n.Rule() {
case exprStmt:
return p.parseExprStmt(n)
case sendStmt:
case incDecStmt:
case assignment:
return p.parseAsignment(n)
case shortVarDecl:
return p.parseShortVarDecl(n)
}
fmt.Println("simpleStmt", n)
return nil
}
func (p *parser) parseLiteralType(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case arrayType:
case structType:
return p.parseStructType(n)
case sliceType:
return p.parseSliceType(n)
case mapType:
case typeName:
default:
// array
}
fmt.Println(n)
return nil
}
func (p *parser) parseTypeLit(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case arrayType:
case structType:
return p.parseStructType(n)
case pointerType:
return p.parsePointerType(n)
case funcType:
case interfaceType:
return p.parseInterfaceType(n)
case sliceType:
case mapType:
case channelType:
}
fmt.Println(n)
return nil
}
func (p *parser) parseStmt(n *parse.Node) ast.Stmt {
n = n.Child(0)
switch n.Rule() {
case decl:
return p.parseDeclStmt(n)
case labeledStmt:
return p.parseLabeledStmt(n)
case simpleStmt:
return p.parseSimpleStmt(n)
case goStmt:
return p.parseGoStmt(n)
case returnStmt:
return p.parseReturnStmt(n)
case breakStmt:
return p.parseBreakStmt(n)
case continueStmt:
return p.parseContinueStmt(n)
case gotoStmt:
return p.parseGotoStmt(n)
case fallthroughStmt:
return p.parseFallthroughStmt(n)
case block:
return p.parseBlockStmt(n)
case ifStmt:
return p.parseIfStmt(n)
case switchStmt:
return p.parseSwitchStmt(n)
case selectStmt:
return p.parseSelectStmt(n)
case forStmt:
return p.parseForStmt(n)
case deferStmt:
return p.parseDeferStmt(n)
}
return nil
}