go/hcl
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

parser: rename methods

Browse Source
This commit is contained in:
Fatih Arslan 2015-10-26 21:37:17 +03:00
parent 26846b5931
commit e6b8a3e7b4
2 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
parser/parser.go
View File

@ -38,10 +38,10 @@ var errEofToken = errors.New("EOF token found")
// Parse returns the fully parsed source and returns the abstract syntax tree. // Parse returns the fully parsed source and returns the abstract syntax tree.
func (p *Parser) Parse() (ast.Node, error) { func (p *Parser) Parse() (ast.Node, error) {
return p.parseObjectList() return p.objectList()
} }
func (p *Parser) parseObjectList() (*ast.ObjectList, error) { func (p *Parser) objectList() (*ast.ObjectList, error) {
defer un(trace(p, "ParseObjectList")) defer un(trace(p, "ParseObjectList"))
node := &ast.ObjectList{} node := &ast.ObjectList{}
@ -79,7 +79,7 @@ func (p *Parser) next() (ast.Node, error) {
return nil, errEofToken return nil, errEofToken
case token.IDENT, token.STRING: case token.IDENT, token.STRING:
p.unscan() p.unscan()
return p.parseObjectItem() return p.objectItem()
case token.COMMENT: case token.COMMENT:
return &ast.Comment{ return &ast.Comment{
Start: tok.Pos, Start: tok.Pos,
@ -90,11 +90,11 @@ func (p *Parser) next() (ast.Node, error) {
} }
} }
// parseObjectItem parses a single object item // objectItem parses a single object item
func (p *Parser) parseObjectItem() (*ast.ObjectItem, error) { func (p *Parser) objectItem() (*ast.ObjectItem, error) {
defer un(trace(p, "ParseObjectItem")) defer un(trace(p, "ParseObjectItem"))
keys, err := p.parseObjectKey() keys, err := p.objectKey()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -107,7 +107,7 @@ func (p *Parser) parseObjectItem() (*ast.ObjectItem, error) {
Assign: p.tok.Pos, Assign: p.tok.Pos,
} }
o.Val, err = p.parseType() o.Val, err = p.object()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -118,7 +118,7 @@ func (p *Parser) parseObjectItem() (*ast.ObjectItem, error) {
Keys: keys, Keys: keys,
} }
o.Val, err = p.parseObjectType() o.Val, err = p.objectType()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -128,8 +128,8 @@ func (p *Parser) parseObjectItem() (*ast.ObjectItem, error) {
return nil, fmt.Errorf("not yet implemented: %s", p.tok.Type) return nil, fmt.Errorf("not yet implemented: %s", p.tok.Type)
} }
// parseObjectKey parses an object key and returns a ObjectKey AST // objectKey parses an object key and returns a ObjectKey AST
func (p *Parser) parseObjectKey() ([]*ast.ObjectKey, error) { func (p *Parser) objectKey() ([]*ast.ObjectKey, error) {
keyCount := 0 keyCount := 0
keys := make([]*ast.ObjectKey, 0) keys := make([]*ast.ObjectKey, 0)
@ -164,19 +164,19 @@ func (p *Parser) parseObjectKey() ([]*ast.ObjectKey, error) {
} }
} }
// parseType parses any type of Type, such as number, bool, string, object or // object parses any type of object, such as number, bool, string, object or
// list. // list.
func (p *Parser) parseType() (ast.Node, error) { func (p *Parser) object() (ast.Node, error) {
defer un(trace(p, "ParseType")) defer un(trace(p, "ParseType"))
tok := p.scan() tok := p.scan()
switch tok.Type { switch tok.Type {
case token.NUMBER, token.FLOAT, token.BOOL, token.STRING: case token.NUMBER, token.FLOAT, token.BOOL, token.STRING:
return p.parseLiteralType() return p.literalType()
case token.LBRACE: case token.LBRACE:
return p.parseObjectType() return p.objectType()
case token.LBRACK: case token.LBRACK:
return p.parseListType() return p.listType()
case token.COMMENT: case token.COMMENT:
// implement comment // implement comment
case token.EOF: case token.EOF:
@ -186,8 +186,8 @@ func (p *Parser) parseType() (ast.Node, error) {
return nil, fmt.Errorf("Unknown token: %+v", tok) return nil, fmt.Errorf("Unknown token: %+v", tok)
} }
// parseObjectType parses an object type and returns a ObjectType AST // ibjectType parses an object type and returns a ObjectType AST
func (p *Parser) parseObjectType() (*ast.ObjectType, error) { func (p *Parser) objectType() (*ast.ObjectType, error) {
defer un(trace(p, "ParseObjectType")) defer un(trace(p, "ParseObjectType"))
// we assume that the currently scanned token is a LBRACE // we assume that the currently scanned token is a LBRACE
@ -195,7 +195,7 @@ func (p *Parser) parseObjectType() (*ast.ObjectType, error) {
Lbrace: p.tok.Pos, Lbrace: p.tok.Pos,
} }
l, err := p.parseObjectList() l, err := p.objectList()
// if we hit RBRACE, we are good to go (means we parsed all Items), if it's // if we hit RBRACE, we are good to go (means we parsed all Items), if it's
// not a RBRACE, it's an syntax error and we just return it. // not a RBRACE, it's an syntax error and we just return it.
@ -208,8 +208,8 @@ func (p *Parser) parseObjectType() (*ast.ObjectType, error) {
return o, nil return o, nil
} }
// parseListType parses a list type and returns a ListType AST // listType parses a list type and returns a ListType AST
func (p *Parser) parseListType() (*ast.ListType, error) { func (p *Parser) listType() (*ast.ListType, error) {
defer un(trace(p, "ParseListType")) defer un(trace(p, "ParseListType"))
// we assume that the currently scanned token is a LBRACK // we assume that the currently scanned token is a LBRACK
@ -221,7 +221,7 @@ func (p *Parser) parseListType() (*ast.ListType, error) {
tok := p.scan() tok := p.scan()
switch tok.Type { switch tok.Type {
case token.NUMBER, token.FLOAT, token.STRING: case token.NUMBER, token.FLOAT, token.STRING:
node, err := p.parseLiteralType() node, err := p.literalType()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -249,8 +249,8 @@ func (p *Parser) parseListType() (*ast.ListType, error) {
} }
} }
// parseLiteralType parses a literal type and returns a LiteralType AST // literalType parses a literal type and returns a LiteralType AST
func (p *Parser) parseLiteralType() (*ast.LiteralType, error) { func (p *Parser) literalType() (*ast.LiteralType, error) {
defer un(trace(p, "ParseLiteral")) defer un(trace(p, "ParseLiteral"))
return &ast.LiteralType{ return &ast.LiteralType{

10
parser/parser_test.go
View File

@ -26,7 +26,7 @@ func TestType(t *testing.T) {
for _, l := range literals { for _, l := range literals {
p := newParser([]byte(l.src)) p := newParser([]byte(l.src))
item, err := p.parseObjectItem() item, err := p.objectItem()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@ -67,7 +67,7 @@ func TestListType(t *testing.T) {
for _, l := range literals { for _, l := range literals {
p := newParser([]byte(l.src)) p := newParser([]byte(l.src))
item, err := p.parseObjectItem() item, err := p.objectItem()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@ -142,7 +142,7 @@ func TestObjectType(t *testing.T) {
for _, l := range literals { for _, l := range literals {
p := newParser([]byte(l.src)) p := newParser([]byte(l.src))
// p.enableTrace = true // p.enableTrace = true
item, err := p.parseObjectItem() item, err := p.objectItem()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@ -185,7 +185,7 @@ func TestObjectKey(t *testing.T) {
for _, k := range keys { for _, k := range keys {
p := newParser([]byte(k.src)) p := newParser([]byte(k.src))
keys, err := p.parseObjectKey() keys, err := p.objectKey()
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -209,7 +209,7 @@ func TestObjectKey(t *testing.T) {
for _, k := range errKeys { for _, k := range errKeys {
p := newParser([]byte(k.src)) p := newParser([]byte(k.src))
_, err := p.parseObjectKey() _, err := p.objectKey()
if err == nil { if err == nil {
t.Errorf("case '%s' should give an error", k.src) t.Errorf("case '%s' should give an error", k.src)
} }