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) parseForStmt(n *parse.Node) (r ast.Stmt) {
p.openScope()
forPos := token.Pos(n.Child(0).Pos())
n = n.Child(1)
if n.Is(block) {
return &ast.ForStmt{
For: forPos,
Body: p.parseBlock(n, p.topScope),
}
}
option := n.Child(0).Child(0)
body := p.parseBlock(n.Child(1), p.topScope)
switch option.Rule() {
case condition:
fmt.Println(option)
case forClause:
fmt.Println(option)
case rangeClause:
forStmt := p.parseRangeStmt(option)
forStmt.For, forStmt.Body = forPos, body
r = forStmt
}
p.closeScope()
return
}
func (p *parser) parseElement(n *parse.Node) ast.Expr {
n = n.Child(0)
if n.Is(value) {
return p.parseValue(n)
}
return p.parseKeyValue(n)
}
func (p *parser) parseSliceType(n *parse.Node) ast.Expr {
return &ast.ArrayType{
Lbrack: token.Pos(n.Child(0).Pos()),
Len: nil,
Elt: p.parseType(n.Child(2)),
}
}
func (p *parser) parsePackageClause(n *parse.Node) (token.Pos, *ast.Ident) {
pac, name := n.Child(0), n.Child(1)
return token.Pos(pac.Pos()), &ast.Ident{
NamePos: token.Pos(name.Pos()),
Name: string(name.Value()),
}
}
func (p *parser) parseStructType(n *parse.Node) ast.Expr {
struct_ := n.Child(0)
return &ast.StructType{
Struct: token.Pos(struct_.Pos()),
// TODO: Fields
}
}
func (p *parser) parseLiteralValue(n *parse.Node) (exprs []ast.Expr) {
if n.ChildCount() == 3 {
eachListItem(element, n.Child(1), func(item *parse.Node) {
exprs = append(exprs, p.parseElement(item))
})
}
return
}
func (p *parser) parseInit(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
fmt.Println(n)
return nil
}
func (p *parser) parseImports(n *parse.Node) (decls []ast.Decl, specs []*ast.ImportSpec) {
n.EachItem(func(item *parse.Node) {
decl, ss := p.parseImportDecl(item.Child(0))
decls = append(decls, decl)
specs = append(specs, ss...)
})
return
}
func newProduct(productNode *parse.Node) *Product {
return &Product{
Name: productNode.Get(productName),
Version: Version{
Text: productNode.Get(productVersion),
},
}
}
func (p *parser) parseCompositeLit(n *parse.Node) ast.Expr {
litValue := n.Child(1)
return &ast.CompositeLit{
Type: p.parseLiteralType(n.Child(0)),
Lbrace: token.Pos(litValue.Child(0).Pos()),
Elts: p.parseLiteralValue(litValue),
Rbrace: token.Pos(litValue.LastChild().Pos()),
}
}
func (p *parser) parseIndex(n *parse.Node) ast.Expr {
index := n.Child(1)
return &ast.IndexExpr{
X: p.parsePrimaryExpr(n.Child(0)),
Lbrack: token.Pos(index.Child(0).Pos()),
Index: p.parseExpr(index.Child(1)),
Rbrack: token.Pos(index.Child(2).Pos()),
}
}
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) parseUnaryExpr(n *parse.Node) ast.Expr {
if n.Child(0).Is(primaryExpr) {
return p.parsePrimaryExpr(n.Child(0))
}
return &ast.UnaryExpr{
OpPos: token.Pos(n.Child(0).Child(0).Pos()),
Op: token.Token(n.Child(0).Child(0).ID()),
X: p.parseUnaryExpr(n.Child(1)),
}
}
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) parsePost(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
if !n.Is(forClause) {
return nil
}
fmt.Println(n)
return nil
}
func (c Comment) append(commentNode *parse.Node) Comment {
commentNode.Child(1).Each(func(citem *parse.Node) {
citem = citem.Child(0)
if citem.Is(commentText) {
c.Items = append(c.Items, citem.Get(commentText))
} else if citem.Is(comment) {
c.Comments = append(c.Comments, Comment{}.append(citem))
}
})
return c
}
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) parseCallExpr(n *parse.Node) *ast.CallExpr {
call := n.Child(1)
callExpr := ast.CallExpr{
Fun: p.parsePrimaryExpr(n.Child(0)),
Lparen: token.Pos(call.Child(0).Pos()),
Rparen: token.Pos(call.LastChild().Pos()),
}
if call.ChildCount() > 2 {
callExpr.Args, callExpr.Ellipsis = p.parseArgs(call.Child(1))
}
return &callExpr
}
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) 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) 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) parseArgs(n *parse.Node) ([]ast.Expr, token.Pos) {
n = n.Child(0)
if n.Is(exprList) {
return p.parseExprList(n), 0
}
return p.parseExprList(n.Child(0)), token.Pos(n.Child(1).Pos())
}
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) parseInitCond(n *parse.Node) (ast.Stmt, ast.Expr) {
n = n.Child(0)
if n.Is(expr) {
return nil, p.parseCond(n)
} else {
return p.parseInit(n.Child(0)), p.parseCond(n.Child(2))
}
}
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 eachListItem(itemRule *parse.R, n *parse.Node, visit func(*parse.Node)) {
if n.Child(0).Is(itemRule) {
visit(n.Child(0))
return
}
n.Child(0).EachItem(func(item *parse.Node) {
visit(item.Child(0))
})
visit(n.Child(1))
}
func (p *parser) parseExpr(n *parse.Node) ast.Expr {
if n == nil {
return nil // ??
}
switch n.ChildCount() {
case 1:
return p.parseUnaryExpr(n.Child(0))
case 3:
op := n.Child(1).Child(0).Child(0)
return &ast.BinaryExpr{
X: p.parseExpr(n.Child(0)),
OpPos: token.Pos(op.Pos()),
Op: token.Token(op.ID()),
Y: p.parseUnaryExpr(n.Child(2)),
}
}
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
}
