Пример #1
0
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)
}
Пример #2
0
func (p *parser) parseStructType(n *parse.Node) ast.Expr {
	struct_ := n.Child(0)
	return &ast.StructType{
		Struct: token.Pos(struct_.Pos()),
		// TODO: Fields
	}
}
Пример #3
0
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()),
	}
}
Пример #4
0
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)
}
Пример #5
0
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)),
	}
}
Пример #6
0
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
}
Пример #7
0
func (p *parser) parseInit(n *parse.Node) ast.Stmt {
	if n == nil {
		return nil
	}
	n = n.Child(0)
	fmt.Println(n)
	return nil
}
Пример #8
0
func (p *parser) parseReturnStmt(n *parse.Node) ast.Stmt {
	ret := ast.ReturnStmt{
		Return: token.Pos(n.Child(0).Pos()),
	}
	if n.ChildCount() > 1 {
		ret.Results = p.parseExprList(n.Child(1))
	}
	return &ret
}
Пример #9
0
func (p *parser) parseSignature(n *parse.Node, scope *ast.Scope) *ast.FuncType {
	funcType := ast.FuncType{
		Params: p.parseParams(n.Child(0), scope),
	}
	if n.ChildCount() > 1 {
		funcType.Results = p.parseResults(n.Child(1), scope)
	}
	return &funcType
}
Пример #10
0
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()),
	}
}
Пример #11
0
func eachInlineListItem(n *parse.Node, visit func(*parse.Node)) {
	visit(n.Child(0))
	if n.ChildCount() > 1 {
		n.Child(1).EachItem(func(item *parse.Node) {
			visit(item.Child(1))
		})
	}
	return
}
Пример #12
0
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()),
	}
}
Пример #13
0
func (p *parser) parseVarSpec(n *parse.Node) *ast.ValueSpec {
	if n.Is(valueSpec) {
		return p.parseValueSpec(n)
	}
	return &ast.ValueSpec{
		Names: p.parseIdentList(n.Child(0)),
		Type:  p.parseType(n.Child(1)),
	}
}
Пример #14
0
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))
}
Пример #15
0
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
}
Пример #16
0
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)),
	}
}
Пример #17
0
func (p *parser) parseBlock(n *parse.Node, scope *ast.Scope) *ast.BlockStmt {
	block := ast.BlockStmt{
		Lbrace: token.Pos(n.Child(0).Pos()),
		Rbrace: token.Pos(n.LastChild().Pos()),
	}
	eachListItem(stmt, n.Child(1), func(item *parse.Node) {
		block.List = append(block.List, p.parseStmt(item))
	})
	return &block
}
Пример #18
0
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
}
Пример #19
0
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
}
Пример #20
0
Файл: ua.go Проект: h12w/gombi
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
}
Пример #21
0
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
}
Пример #22
0
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
}
Пример #23
0
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
}
Пример #24
0
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
}
Пример #25
0
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
}
Пример #26
0
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
}
Пример #27
0
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
}
Пример #28
0
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
}
Пример #29
0
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
}
Пример #30
0
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
}