summaryrefslogtreecommitdiff
path: root/src/pkg/exp/parser/parser.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp/parser/parser.go')
-rw-r--r--src/pkg/exp/parser/parser.go1090
1 files changed, 545 insertions, 545 deletions
diff --git a/src/pkg/exp/parser/parser.go b/src/pkg/exp/parser/parser.go
index 32360b5d6..199334b1b 100644
--- a/src/pkg/exp/parser/parser.go
+++ b/src/pkg/exp/parser/parser.go
@@ -15,11 +15,11 @@
package oldParser
import (
- "container/vector";
- "fmt";
- "go/ast";
- "go/scanner";
- "go/token";
+ "container/vector"
+ "fmt"
+ "go/ast"
+ "go/scanner"
+ "go/token"
)
@@ -32,42 +32,42 @@ var noPos token.Position
// parser functionality.
//
const (
- PackageClauseOnly uint = 1 << iota; // parsing stops after package clause
- ImportsOnly; // parsing stops after import declarations
- ParseComments; // parse comments and add them to AST
- Trace; // print a trace of parsed productions
+ PackageClauseOnly uint = 1 << iota // parsing stops after package clause
+ ImportsOnly // parsing stops after import declarations
+ ParseComments // parse comments and add them to AST
+ Trace // print a trace of parsed productions
)
// The parser structure holds the parser's internal state.
type parser struct {
- scanner.ErrorVector;
- scanner scanner.Scanner;
+ scanner.ErrorVector
+ scanner scanner.Scanner
// Tracing/debugging
- mode uint; // parsing mode
- trace bool; // == (mode & Trace != 0)
- indent uint; // indentation used for tracing output
+ mode uint // parsing mode
+ trace bool // == (mode & Trace != 0)
+ indent uint // indentation used for tracing output
// Comments
- comments *ast.CommentGroup; // list of collected comments
- lastComment *ast.CommentGroup; // last comment in the comments list
- leadComment *ast.CommentGroup; // the last lead comment
- lineComment *ast.CommentGroup; // the last line comment
+ comments *ast.CommentGroup // list of collected comments
+ lastComment *ast.CommentGroup // last comment in the comments list
+ leadComment *ast.CommentGroup // the last lead comment
+ lineComment *ast.CommentGroup // the last line comment
// Next token
- pos token.Position; // token position
- tok token.Token; // one token look-ahead
- lit []byte; // token literal
+ pos token.Position // token position
+ tok token.Token // one token look-ahead
+ lit []byte // token literal
// Non-syntactic parser control
- optSemi bool; // true if semicolon separator is optional in statement list
- exprLev int; // < 0: in control clause, >= 0: in expression
+ optSemi bool // true if semicolon separator is optional in statement list
+ exprLev int // < 0: in control clause, >= 0: in expression
// Scopes
- pkgScope *ast.Scope;
- fileScope *ast.Scope;
- topScope *ast.Scope;
+ pkgScope *ast.Scope
+ fileScope *ast.Scope
+ topScope *ast.Scope
}
@@ -76,15 +76,15 @@ func scannerMode(mode uint) uint {
if mode&ParseComments != 0 {
return scanner.ScanComments
}
- return 0;
+ return 0
}
func (p *parser) init(filename string, src []byte, mode uint) {
- p.scanner.Init(filename, src, p, scannerMode(mode));
- p.mode = mode;
- p.trace = mode&Trace != 0; // for convenience (p.trace is used frequently)
- p.next();
+ p.scanner.Init(filename, src, p, scannerMode(mode))
+ p.mode = mode
+ p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
+ p.next()
}
@@ -93,29 +93,29 @@ func (p *parser) init(filename string, src []byte, mode uint) {
func (p *parser) printTrace(a ...) {
const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
- ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";
- const n = uint(len(dots));
- fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column);
- i := 2 * p.indent;
+ ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
+ const n = uint(len(dots))
+ fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column)
+ i := 2 * p.indent
for ; i > n; i -= n {
fmt.Print(dots)
}
- fmt.Print(dots[0:i]);
- fmt.Println(a);
+ fmt.Print(dots[0:i])
+ fmt.Println(a)
}
func trace(p *parser, msg string) *parser {
- p.printTrace(msg, "(");
- p.indent++;
- return p;
+ p.printTrace(msg, "(")
+ p.indent++
+ return p
}
// Usage pattern: defer un(trace(p, "..."));
func un(p *parser) {
- p.indent--;
- p.printTrace(")");
+ p.indent--
+ p.printTrace(")")
}
@@ -126,7 +126,7 @@ func (p *parser) next0() {
// very first token (p.pos.Line == 0) is not initialized (it
// is token.ILLEGAL), so don't print it .
if p.trace && p.pos.Line > 0 {
- s := p.tok.String();
+ s := p.tok.String()
switch {
case p.tok.IsLiteral():
p.printTrace(s, string(p.lit))
@@ -137,8 +137,8 @@ func (p *parser) next0() {
}
}
- p.pos, p.tok, p.lit = p.scanner.Scan();
- p.optSemi = false;
+ p.pos, p.tok, p.lit = p.scanner.Scan()
+ p.optSemi = false
}
@@ -146,7 +146,7 @@ func (p *parser) next0() {
func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
// /*-style comments may end on a different line than where they start.
// Scan the comment for '\n' chars and adjust endline accordingly.
- endline = p.pos.Line;
+ endline = p.pos.Line
if p.lit[1] == '*' {
for _, b := range p.lit {
if b == '\n' {
@@ -155,10 +155,10 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
}
}
- comment = &ast.Comment{p.pos, p.lit};
- p.next0();
+ comment = &ast.Comment{p.pos, p.lit}
+ p.next0()
- return;
+ return
}
@@ -168,30 +168,30 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
// a comment group.
//
func (p *parser) consumeCommentGroup() int {
- list := new(vector.Vector);
- endline := p.pos.Line;
+ list := new(vector.Vector)
+ endline := p.pos.Line
for p.tok == token.COMMENT && endline+1 >= p.pos.Line {
- var comment *ast.Comment;
- comment, endline = p.consumeComment();
- list.Push(comment);
+ var comment *ast.Comment
+ comment, endline = p.consumeComment()
+ list.Push(comment)
}
// convert list
- group := make([]*ast.Comment, list.Len());
+ group := make([]*ast.Comment, list.Len())
for i := 0; i < list.Len(); i++ {
group[i] = list.At(i).(*ast.Comment)
}
// add comment group to the comments list
- g := &ast.CommentGroup{group, nil};
+ g := &ast.CommentGroup{group, nil}
if p.lastComment != nil {
p.lastComment.Next = g
} else {
p.comments = g
}
- p.lastComment = g;
+ p.lastComment = g
- return endline;
+ return endline
}
@@ -211,16 +211,16 @@ func (p *parser) consumeCommentGroup() int {
// stored in the AST.
//
func (p *parser) next() {
- p.leadComment = nil;
- p.lineComment = nil;
- line := p.pos.Line; // current line
- p.next0();
+ p.leadComment = nil
+ p.lineComment = nil
+ line := p.pos.Line // current line
+ p.next0()
if p.tok == token.COMMENT {
if p.pos.Line == line {
// The comment is on same line as previous token; it
// cannot be a lead comment but may be a line comment.
- endline := p.consumeCommentGroup();
+ endline := p.consumeCommentGroup()
if p.pos.Line != endline {
// The next token is on a different line, thus
// the last comment group is a line comment.
@@ -229,7 +229,7 @@ func (p *parser) next() {
}
// consume successor comments, if any
- endline := -1;
+ endline := -1
for p.tok == token.COMMENT {
endline = p.consumeCommentGroup()
}
@@ -244,26 +244,26 @@ func (p *parser) next() {
func (p *parser) errorExpected(pos token.Position, msg string) {
- msg = "expected " + msg;
+ msg = "expected " + msg
if pos.Offset == p.pos.Offset {
// the error happened at the current position;
// make the error message more specific
- msg += ", found '" + p.tok.String() + "'";
+ msg += ", found '" + p.tok.String() + "'"
if p.tok.IsLiteral() {
msg += " " + string(p.lit)
}
}
- p.Error(pos, msg);
+ p.Error(pos, msg)
}
func (p *parser) expect(tok token.Token) token.Position {
- pos := p.pos;
+ pos := p.pos
if p.tok != tok {
p.errorExpected(pos, "'"+tok.String()+"'")
}
- p.next(); // make progress in any case
- return pos;
+ p.next() // make progress in any case
+ return pos
}
@@ -271,13 +271,13 @@ func (p *parser) expect(tok token.Token) token.Position {
// Scope support
func openScope(p *parser) *parser {
- p.topScope = ast.NewScope(p.topScope);
- return p;
+ p.topScope = ast.NewScope(p.topScope)
+ return p
}
// Usage pattern: defer close(openScope(p));
-func close(p *parser) { p.topScope = p.topScope.Outer }
+func close(p *parser) { p.topScope = p.topScope.Outer }
func (p *parser) declare(ident *ast.Ident) {
@@ -299,12 +299,12 @@ func (p *parser) declareList(idents []*ast.Ident) {
func (p *parser) parseIdent() *ast.Ident {
if p.tok == token.IDENT {
- x := &ast.Ident{p.pos, string(p.lit)};
- p.next();
- return x;
+ x := &ast.Ident{p.pos, string(p.lit)}
+ p.next()
+ return x
}
- p.expect(token.IDENT); // use expect() error handling
- return &ast.Ident{p.pos, ""};
+ p.expect(token.IDENT) // use expect() error handling
+ return &ast.Ident{p.pos, ""}
}
@@ -313,20 +313,20 @@ func (p *parser) parseIdentList() []*ast.Ident {
defer un(trace(p, "IdentList"))
}
- list := new(vector.Vector);
- list.Push(p.parseIdent());
+ list := new(vector.Vector)
+ list.Push(p.parseIdent())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseIdent());
+ p.next()
+ list.Push(p.parseIdent())
}
// convert vector
- idents := make([]*ast.Ident, list.Len());
+ idents := make([]*ast.Ident, list.Len())
for i := 0; i < list.Len(); i++ {
idents[i] = list.At(i).(*ast.Ident)
}
- return idents;
+ return idents
}
@@ -335,20 +335,20 @@ func (p *parser) parseExprList() []ast.Expr {
defer un(trace(p, "ExpressionList"))
}
- list := new(vector.Vector);
- list.Push(p.parseExpr());
+ list := new(vector.Vector)
+ list.Push(p.parseExpr())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseExpr());
+ p.next()
+ list.Push(p.parseExpr())
}
// convert list
- exprs := make([]ast.Expr, list.Len());
+ exprs := make([]ast.Expr, list.Len())
for i := 0; i < list.Len(); i++ {
exprs[i] = list.At(i).(ast.Expr)
}
- return exprs;
+ return exprs
}
@@ -360,15 +360,15 @@ func (p *parser) parseType() ast.Expr {
defer un(trace(p, "Type"))
}
- typ := p.tryType();
+ typ := p.tryType()
if typ == nil {
- p.errorExpected(p.pos, "type");
- p.next(); // make progress
- return &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "type")
+ p.next() // make progress
+ return &ast.BadExpr{p.pos}
}
- return typ;
+ return typ
}
@@ -377,14 +377,14 @@ func (p *parser) parseQualifiedIdent() ast.Expr {
defer un(trace(p, "QualifiedIdent"))
}
- var x ast.Expr = p.parseIdent();
+ var x ast.Expr = p.parseIdent()
if p.tok == token.PERIOD {
// first identifier is a package identifier
- p.next();
- sel := p.parseIdent();
- x = &ast.SelectorExpr{x, sel};
+ p.next()
+ sel := p.parseIdent()
+ x = &ast.SelectorExpr{x, sel}
}
- return x;
+ return x
}
@@ -393,7 +393,7 @@ func (p *parser) parseTypeName() ast.Expr {
defer un(trace(p, "TypeName"))
}
- return p.parseQualifiedIdent();
+ return p.parseQualifiedIdent()
}
@@ -402,33 +402,33 @@ func (p *parser) parseArrayType(ellipsisOk bool) ast.Expr {
defer un(trace(p, "ArrayType"))
}
- lbrack := p.expect(token.LBRACK);
- var len ast.Expr;
+ lbrack := p.expect(token.LBRACK)
+ var len ast.Expr
if ellipsisOk && p.tok == token.ELLIPSIS {
- len = &ast.Ellipsis{p.pos};
- p.next();
+ len = &ast.Ellipsis{p.pos}
+ p.next()
} else if p.tok != token.RBRACK {
len = p.parseExpr()
}
- p.expect(token.RBRACK);
- elt := p.parseType();
+ p.expect(token.RBRACK)
+ elt := p.parseType()
- return &ast.ArrayType{lbrack, len, elt};
+ return &ast.ArrayType{lbrack, len, elt}
}
func (p *parser) makeIdentList(list *vector.Vector) []*ast.Ident {
- idents := make([]*ast.Ident, list.Len());
+ idents := make([]*ast.Ident, list.Len())
for i := 0; i < list.Len(); i++ {
- ident, isIdent := list.At(i).(*ast.Ident);
+ ident, isIdent := list.At(i).(*ast.Ident)
if !isIdent {
- pos := list.At(i).(ast.Expr).Pos();
- p.errorExpected(pos, "identifier");
- idents[i] = &ast.Ident{pos, ""};
+ pos := list.At(i).(ast.Expr).Pos()
+ p.errorExpected(pos, "identifier")
+ idents[i] = &ast.Ident{pos, ""}
}
- idents[i] = ident;
+ idents[i] = ident
}
- return idents;
+ return idents
}
@@ -437,13 +437,13 @@ func (p *parser) parseFieldDecl() *ast.Field {
defer un(trace(p, "FieldDecl"))
}
- doc := p.leadComment;
+ doc := p.leadComment
// a list of identifiers looks like a list of type names
- list := new(vector.Vector);
+ list := new(vector.Vector)
for {
// TODO(gri): do not allow ()'s here
- list.Push(p.parseType());
+ list.Push(p.parseType())
if p.tok == token.COMMA {
p.next()
} else {
@@ -452,16 +452,16 @@ func (p *parser) parseFieldDecl() *ast.Field {
}
// if we had a list of identifiers, it must be followed by a type
- typ := p.tryType();
+ typ := p.tryType()
// optional tag
- var tag []*ast.BasicLit;
+ var tag []*ast.BasicLit
if p.tok == token.STRING {
tag = p.parseStringList(nil)
}
// analyze case
- var idents []*ast.Ident;
+ var idents []*ast.Ident
if typ != nil {
// IdentifierList Type
idents = p.makeIdentList(list)
@@ -471,12 +471,12 @@ func (p *parser) parseFieldDecl() *ast.Field {
// TODO(gri): check that this looks like a type
typ = list.At(0).(ast.Expr)
} else {
- p.errorExpected(p.pos, "anonymous field");
- typ = &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "anonymous field")
+ typ = &ast.BadExpr{p.pos}
}
}
- return &ast.Field{doc, idents, typ, tag, nil};
+ return &ast.Field{doc, idents, typ, tag, nil}
}
@@ -485,27 +485,27 @@ func (p *parser) parseStructType() *ast.StructType {
defer un(trace(p, "StructType"))
}
- pos := p.expect(token.STRUCT);
- lbrace := p.expect(token.LBRACE);
- list := new(vector.Vector);
+ pos := p.expect(token.STRUCT)
+ lbrace := p.expect(token.LBRACE)
+ list := new(vector.Vector)
for p.tok == token.IDENT || p.tok == token.MUL {
- f := p.parseFieldDecl();
+ f := p.parseFieldDecl()
if p.tok != token.RBRACE {
p.expect(token.SEMICOLON)
}
- f.Comment = p.lineComment;
- list.Push(f);
+ f.Comment = p.lineComment
+ list.Push(f)
}
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
// convert vector
- fields := make([]*ast.Field, list.Len());
+ fields := make([]*ast.Field, list.Len())
for i := list.Len() - 1; i >= 0; i-- {
fields[i] = list.At(i).(*ast.Field)
}
- return &ast.StructType{pos, lbrace, fields, rbrace, false};
+ return &ast.StructType{pos, lbrace, fields, rbrace, false}
}
@@ -514,35 +514,35 @@ func (p *parser) parsePointerType() *ast.StarExpr {
defer un(trace(p, "PointerType"))
}
- star := p.expect(token.MUL);
- base := p.parseType();
+ star := p.expect(token.MUL)
+ base := p.parseType()
- return &ast.StarExpr{star, base};
+ return &ast.StarExpr{star, base}
}
func (p *parser) tryParameterType(ellipsisOk bool) ast.Expr {
if ellipsisOk && p.tok == token.ELLIPSIS {
- pos := p.pos;
- p.next();
+ pos := p.pos
+ p.next()
if p.tok != token.RPAREN {
// "..." always must be at the very end of a parameter list
p.Error(pos, "expected type, found '...'")
}
- return &ast.Ellipsis{pos};
+ return &ast.Ellipsis{pos}
}
- return p.tryType();
+ return p.tryType()
}
func (p *parser) parseParameterType(ellipsisOk bool) ast.Expr {
- typ := p.tryParameterType(ellipsisOk);
+ typ := p.tryParameterType(ellipsisOk)
if typ == nil {
- p.errorExpected(p.pos, "type");
- p.next(); // make progress
- typ = &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "type")
+ p.next() // make progress
+ typ = &ast.BadExpr{p.pos}
}
- return typ;
+ return typ
}
@@ -552,10 +552,10 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr)
}
// a list of identifiers looks like a list of type names
- list := new(vector.Vector);
+ list := new(vector.Vector)
for {
// TODO(gri): do not allow ()'s here
- list.Push(p.parseParameterType(ellipsisOk));
+ list.Push(p.parseParameterType(ellipsisOk))
if p.tok == token.COMMA {
p.next()
} else {
@@ -564,9 +564,9 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr)
}
// if we had a list of identifiers, it must be followed by a type
- typ := p.tryParameterType(ellipsisOk);
+ typ := p.tryParameterType(ellipsisOk)
- return list, typ;
+ return list, typ
}
@@ -575,18 +575,18 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field {
defer un(trace(p, "ParameterList"))
}
- list, typ := p.parseParameterDecl(ellipsisOk);
+ list, typ := p.parseParameterDecl(ellipsisOk)
if typ != nil {
// IdentifierList Type
- idents := p.makeIdentList(list);
- list.Resize(0, 0);
- list.Push(&ast.Field{nil, idents, typ, nil, nil});
+ idents := p.makeIdentList(list)
+ list.Resize(0, 0)
+ list.Push(&ast.Field{nil, idents, typ, nil, nil})
for p.tok == token.COMMA {
- p.next();
- idents := p.parseIdentList();
- typ := p.parseParameterType(ellipsisOk);
- list.Push(&ast.Field{nil, idents, typ, nil, nil});
+ p.next()
+ idents := p.parseIdentList()
+ typ := p.parseParameterType(ellipsisOk)
+ list.Push(&ast.Field{nil, idents, typ, nil, nil})
}
} else {
@@ -598,12 +598,12 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field {
}
// convert list
- params := make([]*ast.Field, list.Len());
+ params := make([]*ast.Field, list.Len())
for i := 0; i < list.Len(); i++ {
params[i] = list.At(i).(*ast.Field)
}
- return params;
+ return params
}
@@ -612,14 +612,14 @@ func (p *parser) parseParameters(ellipsisOk bool) []*ast.Field {
defer un(trace(p, "Parameters"))
}
- var params []*ast.Field;
- p.expect(token.LPAREN);
+ var params []*ast.Field
+ p.expect(token.LPAREN)
if p.tok != token.RPAREN {
params = p.parseParameterList(ellipsisOk)
}
- p.expect(token.RPAREN);
+ p.expect(token.RPAREN)
- return params;
+ return params
}
@@ -628,18 +628,18 @@ func (p *parser) parseResult() []*ast.Field {
defer un(trace(p, "Result"))
}
- var results []*ast.Field;
+ var results []*ast.Field
if p.tok == token.LPAREN {
results = p.parseParameters(false)
} else if p.tok != token.FUNC {
- typ := p.tryType();
+ typ := p.tryType()
if typ != nil {
- results = make([]*ast.Field, 1);
- results[0] = &ast.Field{Type: typ};
+ results = make([]*ast.Field, 1)
+ results[0] = &ast.Field{Type: typ}
}
}
- return results;
+ return results
}
@@ -648,10 +648,10 @@ func (p *parser) parseSignature() (params []*ast.Field, results []*ast.Field) {
defer un(trace(p, "Signature"))
}
- params = p.parseParameters(true);
- results = p.parseResult();
+ params = p.parseParameters(true)
+ results = p.parseResult()
- return;
+ return
}
@@ -660,10 +660,10 @@ func (p *parser) parseFuncType() *ast.FuncType {
defer un(trace(p, "FuncType"))
}
- pos := p.expect(token.FUNC);
- params, results := p.parseSignature();
+ pos := p.expect(token.FUNC)
+ params, results := p.parseSignature()
- return &ast.FuncType{pos, params, results};
+ return &ast.FuncType{pos, params, results}
}
@@ -672,21 +672,21 @@ func (p *parser) parseMethodSpec() *ast.Field {
defer un(trace(p, "MethodSpec"))
}
- doc := p.leadComment;
- var idents []*ast.Ident;
- var typ ast.Expr;
- x := p.parseQualifiedIdent();
+ doc := p.leadComment
+ var idents []*ast.Ident
+ var typ ast.Expr
+ x := p.parseQualifiedIdent()
if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
// method
- idents = []*ast.Ident{ident};
- params, results := p.parseSignature();
- typ = &ast.FuncType{noPos, params, results};
+ idents = []*ast.Ident{ident}
+ params, results := p.parseSignature()
+ typ = &ast.FuncType{noPos, params, results}
} else {
// embedded interface
typ = x
}
- return &ast.Field{doc, idents, typ, nil, nil};
+ return &ast.Field{doc, idents, typ, nil, nil}
}
@@ -695,27 +695,27 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType {
defer un(trace(p, "InterfaceType"))
}
- pos := p.expect(token.INTERFACE);
- lbrace := p.expect(token.LBRACE);
- list := new(vector.Vector);
+ pos := p.expect(token.INTERFACE)
+ lbrace := p.expect(token.LBRACE)
+ list := new(vector.Vector)
for p.tok == token.IDENT {
- m := p.parseMethodSpec();
+ m := p.parseMethodSpec()
if p.tok != token.RBRACE {
p.expect(token.SEMICOLON)
}
- m.Comment = p.lineComment;
- list.Push(m);
+ m.Comment = p.lineComment
+ list.Push(m)
}
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
// convert vector
- methods := make([]*ast.Field, list.Len());
+ methods := make([]*ast.Field, list.Len())
for i := list.Len() - 1; i >= 0; i-- {
methods[i] = list.At(i).(*ast.Field)
}
- return &ast.InterfaceType{pos, lbrace, methods, rbrace, false};
+ return &ast.InterfaceType{pos, lbrace, methods, rbrace, false}
}
@@ -724,13 +724,13 @@ func (p *parser) parseMapType() *ast.MapType {
defer un(trace(p, "MapType"))
}
- pos := p.expect(token.MAP);
- p.expect(token.LBRACK);
- key := p.parseType();
- p.expect(token.RBRACK);
- value := p.parseType();
+ pos := p.expect(token.MAP)
+ p.expect(token.LBRACK)
+ key := p.parseType()
+ p.expect(token.RBRACK)
+ value := p.parseType()
- return &ast.MapType{pos, key, value};
+ return &ast.MapType{pos, key, value}
}
@@ -739,22 +739,22 @@ func (p *parser) parseChanType() *ast.ChanType {
defer un(trace(p, "ChanType"))
}
- pos := p.pos;
- dir := ast.SEND | ast.RECV;
+ pos := p.pos
+ dir := ast.SEND | ast.RECV
if p.tok == token.CHAN {
- p.next();
+ p.next()
if p.tok == token.ARROW {
- p.next();
- dir = ast.SEND;
+ p.next()
+ dir = ast.SEND
}
} else {
- p.expect(token.ARROW);
- p.expect(token.CHAN);
- dir = ast.RECV;
+ p.expect(token.ARROW)
+ p.expect(token.CHAN)
+ dir = ast.RECV
}
- value := p.parseType();
+ value := p.parseType()
- return &ast.ChanType{pos, dir, value};
+ return &ast.ChanType{pos, dir, value}
}
@@ -777,30 +777,30 @@ func (p *parser) tryRawType(ellipsisOk bool) ast.Expr {
case token.CHAN, token.ARROW:
return p.parseChanType()
case token.LPAREN:
- lparen := p.pos;
- p.next();
- typ := p.parseType();
- rparen := p.expect(token.RPAREN);
- return &ast.ParenExpr{lparen, typ, rparen};
+ lparen := p.pos
+ p.next()
+ typ := p.parseType()
+ rparen := p.expect(token.RPAREN)
+ return &ast.ParenExpr{lparen, typ, rparen}
}
// no type found
- return nil;
+ return nil
}
-func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
+func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
// ----------------------------------------------------------------------------
// Blocks
func makeStmtList(list *vector.Vector) []ast.Stmt {
- stats := make([]ast.Stmt, list.Len());
+ stats := make([]ast.Stmt, list.Len())
for i := 0; i < list.Len(); i++ {
stats[i] = list.At(i).(ast.Stmt)
}
- return stats;
+ return stats
}
@@ -809,24 +809,24 @@ func (p *parser) parseStmtList() []ast.Stmt {
defer un(trace(p, "StatementList"))
}
- list := new(vector.Vector);
- expectSemi := false;
+ list := new(vector.Vector)
+ expectSemi := false
for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
if expectSemi {
- p.expect(token.SEMICOLON);
- expectSemi = false;
+ p.expect(token.SEMICOLON)
+ expectSemi = false
}
- list.Push(p.parseStmt());
+ list.Push(p.parseStmt())
if p.tok == token.SEMICOLON {
p.next()
} else if p.optSemi {
- p.optSemi = false // "consume" optional semicolon
+ p.optSemi = false // "consume" optional semicolon
} else {
expectSemi = true
}
}
- return makeStmtList(list);
+ return makeStmtList(list)
}
@@ -835,14 +835,14 @@ func (p *parser) parseBlockStmt(idents []*ast.Ident) *ast.BlockStmt {
defer un(trace(p, "BlockStmt"))
}
- defer close(openScope(p));
+ defer close(openScope(p))
- lbrace := p.expect(token.LBRACE);
- list := p.parseStmtList();
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
+ lbrace := p.expect(token.LBRACE)
+ list := p.parseStmtList()
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
- return &ast.BlockStmt{lbrace, list, rbrace};
+ return &ast.BlockStmt{lbrace, list, rbrace}
}
@@ -854,23 +854,23 @@ func (p *parser) parseStringList(x *ast.BasicLit) []*ast.BasicLit {
defer un(trace(p, "StringList"))
}
- list := new(vector.Vector);
+ list := new(vector.Vector)
if x != nil {
list.Push(x)
}
for p.tok == token.STRING {
- list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit});
- p.next();
+ list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit})
+ p.next()
}
// convert list
- strings := make([]*ast.BasicLit, list.Len());
+ strings := make([]*ast.BasicLit, list.Len())
for i := 0; i < list.Len(); i++ {
strings[i] = list.At(i).(*ast.BasicLit)
}
- return strings;
+ return strings
}
@@ -879,18 +879,18 @@ func (p *parser) parseFuncTypeOrLit() ast.Expr {
defer un(trace(p, "FuncTypeOrLit"))
}
- typ := p.parseFuncType();
+ typ := p.parseFuncType()
if p.tok != token.LBRACE {
// function type only
return typ
}
- p.exprLev++;
- body := p.parseBlockStmt(nil);
- p.optSemi = false; // function body requires separating ";"
- p.exprLev--;
+ p.exprLev++
+ body := p.parseBlockStmt(nil)
+ p.optSemi = false // function body requires separating ";"
+ p.exprLev--
- return &ast.FuncLit{typ, body};
+ return &ast.FuncLit{typ, body}
}
@@ -907,35 +907,35 @@ func (p *parser) parseOperand() ast.Expr {
return p.parseIdent()
case token.INT, token.FLOAT, token.CHAR, token.STRING:
- x := &ast.BasicLit{p.pos, p.tok, p.lit};
- p.next();
+ x := &ast.BasicLit{p.pos, p.tok, p.lit}
+ p.next()
if p.tok == token.STRING && p.tok == token.STRING {
return &ast.StringList{p.parseStringList(x)}
}
- return x;
+ return x
case token.LPAREN:
- lparen := p.pos;
- p.next();
- p.exprLev++;
- x := p.parseExpr();
- p.exprLev--;
- rparen := p.expect(token.RPAREN);
- return &ast.ParenExpr{lparen, x, rparen};
+ lparen := p.pos
+ p.next()
+ p.exprLev++
+ x := p.parseExpr()
+ p.exprLev--
+ rparen := p.expect(token.RPAREN)
+ return &ast.ParenExpr{lparen, x, rparen}
case token.FUNC:
return p.parseFuncTypeOrLit()
default:
- t := p.tryRawType(true); // could be type for composite literal or conversion
+ t := p.tryRawType(true) // could be type for composite literal or conversion
if t != nil {
return t
}
}
- p.errorExpected(p.pos, "operand");
- p.next(); // make progress
- return &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "operand")
+ p.next() // make progress
+ return &ast.BadExpr{p.pos}
}
@@ -944,25 +944,25 @@ func (p *parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
defer un(trace(p, "SelectorOrTypeAssertion"))
}
- p.expect(token.PERIOD);
+ p.expect(token.PERIOD)
if p.tok == token.IDENT {
// selector
- sel := p.parseIdent();
- return &ast.SelectorExpr{x, sel};
+ sel := p.parseIdent()
+ return &ast.SelectorExpr{x, sel}
}
// type assertion
- p.expect(token.LPAREN);
- var typ ast.Expr;
+ p.expect(token.LPAREN)
+ var typ ast.Expr
if p.tok == token.TYPE {
// type switch: typ == nil
p.next()
} else {
typ = p.parseType()
}
- p.expect(token.RPAREN);
+ p.expect(token.RPAREN)
- return &ast.TypeAssertExpr{x, typ};
+ return &ast.TypeAssertExpr{x, typ}
}
@@ -971,23 +971,23 @@ func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
defer un(trace(p, "IndexOrSlice"))
}
- p.expect(token.LBRACK);
- p.exprLev++;
- index := p.parseExpr();
+ p.expect(token.LBRACK)
+ p.exprLev++
+ index := p.parseExpr()
if p.tok == token.COLON {
- p.next();
- var end ast.Expr;
+ p.next()
+ var end ast.Expr
if p.tok != token.RBRACK {
end = p.parseExpr()
}
- x = &ast.SliceExpr{x, index, end};
+ x = &ast.SliceExpr{x, index, end}
} else {
x = &ast.IndexExpr{x, index}
}
- p.exprLev--;
- p.expect(token.RBRACK);
+ p.exprLev--
+ p.expect(token.RBRACK)
- return x;
+ return x
}
@@ -996,16 +996,16 @@ func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
defer un(trace(p, "CallOrConversion"))
}
- lparen := p.expect(token.LPAREN);
- p.exprLev++;
- var args []ast.Expr;
+ lparen := p.expect(token.LPAREN)
+ p.exprLev++
+ var args []ast.Expr
if p.tok != token.RPAREN {
args = p.parseExprList()
}
- p.exprLev--;
- rparen := p.expect(token.RPAREN);
+ p.exprLev--
+ rparen := p.expect(token.RPAREN)
- return &ast.CallExpr{fun, lparen, args, rparen};
+ return &ast.CallExpr{fun, lparen, args, rparen}
}
@@ -1014,14 +1014,14 @@ func (p *parser) parseElement() ast.Expr {
defer un(trace(p, "Element"))
}
- x := p.parseExpr();
+ x := p.parseExpr()
if p.tok == token.COLON {
- colon := p.pos;
- p.next();
- x = &ast.KeyValueExpr{x, colon, p.parseExpr()};
+ colon := p.pos
+ p.next()
+ x = &ast.KeyValueExpr{x, colon, p.parseExpr()}
}
- return x;
+ return x
}
@@ -1030,9 +1030,9 @@ func (p *parser) parseElementList() []ast.Expr {
defer un(trace(p, "ElementList"))
}
- list := new(vector.Vector);
+ list := new(vector.Vector)
for p.tok != token.RBRACE && p.tok != token.EOF {
- list.Push(p.parseElement());
+ list.Push(p.parseElement())
if p.tok == token.COMMA {
p.next()
} else {
@@ -1041,12 +1041,12 @@ func (p *parser) parseElementList() []ast.Expr {
}
// convert list
- elts := make([]ast.Expr, list.Len());
+ elts := make([]ast.Expr, list.Len())
for i := 0; i < list.Len(); i++ {
elts[i] = list.At(i).(ast.Expr)
}
- return elts;
+ return elts
}
@@ -1055,13 +1055,13 @@ func (p *parser) parseCompositeLit(typ ast.Expr) ast.Expr {
defer un(trace(p, "CompositeLit"))
}
- lbrace := p.expect(token.LBRACE);
- var elts []ast.Expr;
+ lbrace := p.expect(token.LBRACE)
+ var elts []ast.Expr
if p.tok != token.RBRACE {
elts = p.parseElementList()
}
- rbrace := p.expect(token.RBRACE);
- return &ast.CompositeLit{typ, lbrace, elts, rbrace};
+ rbrace := p.expect(token.RBRACE)
+ return &ast.CompositeLit{typ, lbrace, elts, rbrace}
}
@@ -1087,24 +1087,24 @@ func (p *parser) checkExpr(x ast.Expr) ast.Expr {
case *ast.TypeAssertExpr:
if t.Type == nil {
// the form X.(type) is only allowed in type switch expressions
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.CallExpr:
case *ast.StarExpr:
case *ast.UnaryExpr:
if t.Op == token.RANGE {
// the range operator is only allowed at the top of a for statement
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.BinaryExpr:
default:
// all other nodes are not proper expressions
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
- return x;
+ return x
}
@@ -1115,13 +1115,13 @@ func isTypeName(x ast.Expr) bool {
case *ast.BadExpr:
case *ast.Ident:
case *ast.ParenExpr:
- return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal?
+ return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal?
case *ast.SelectorExpr:
return isTypeName(t.X)
default:
- return false // all other nodes are not type names
+ return false // all other nodes are not type names
}
- return true;
+ return true
}
@@ -1139,9 +1139,9 @@ func isCompositeLitType(x ast.Expr) bool {
case *ast.StructType:
case *ast.MapType:
default:
- return false // all other nodes are not legal composite literal types
+ return false // all other nodes are not legal composite literal types
}
- return true;
+ return true
}
@@ -1154,18 +1154,18 @@ func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
case *ast.UnaryExpr:
if t.Op == token.RANGE {
// the range operator is only allowed at the top of a for statement
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.ArrayType:
if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis {
- p.Error(len.Pos(), "expected array length, found '...'");
- x = &ast.BadExpr{x.Pos()};
+ p.Error(len.Pos(), "expected array length, found '...'")
+ x = &ast.BadExpr{x.Pos()}
}
}
// all other nodes are expressions or types
- return x;
+ return x
}
@@ -1174,8 +1174,8 @@ func (p *parser) parsePrimaryExpr() ast.Expr {
defer un(trace(p, "PrimaryExpr"))
}
- x := p.parseOperand();
-L: for {
+ x := p.parseOperand()
+L: for {
switch p.tok {
case token.PERIOD:
x = p.parseSelectorOrTypeAssertion(p.checkExpr(x))
@@ -1194,7 +1194,7 @@ L: for {
}
}
- return x;
+ return x
}
@@ -1205,20 +1205,20 @@ func (p *parser) parseUnaryExpr() ast.Expr {
switch p.tok {
case token.ADD, token.SUB, token.NOT, token.XOR, token.ARROW, token.AND, token.RANGE:
- pos, op := p.pos, p.tok;
- p.next();
- x := p.parseUnaryExpr();
- return &ast.UnaryExpr{pos, op, p.checkExpr(x)};
+ pos, op := p.pos, p.tok
+ p.next()
+ x := p.parseUnaryExpr()
+ return &ast.UnaryExpr{pos, op, p.checkExpr(x)}
case token.MUL:
// unary "*" expression or pointer type
- pos := p.pos;
- p.next();
- x := p.parseUnaryExpr();
- return &ast.StarExpr{pos, p.checkExprOrType(x)};
+ pos := p.pos
+ p.next()
+ x := p.parseUnaryExpr()
+ return &ast.StarExpr{pos, p.checkExprOrType(x)}
}
- return p.parsePrimaryExpr();
+ return p.parsePrimaryExpr()
}
@@ -1227,17 +1227,17 @@ func (p *parser) parseBinaryExpr(prec1 int) ast.Expr {
defer un(trace(p, "BinaryExpr"))
}
- x := p.parseUnaryExpr();
+ x := p.parseUnaryExpr()
for prec := p.tok.Precedence(); prec >= prec1; prec-- {
for p.tok.Precedence() == prec {
- pos, op := p.pos, p.tok;
- p.next();
- y := p.parseBinaryExpr(prec + 1);
- x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)};
+ pos, op := p.pos, p.tok
+ p.next()
+ y := p.parseBinaryExpr(prec + 1)
+ x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}
}
}
- return x;
+ return x
}
@@ -1248,7 +1248,7 @@ func (p *parser) parseExpr() ast.Expr {
defer un(trace(p, "Expression"))
}
- return p.parseBinaryExpr(token.LowestPrec + 1);
+ return p.parseBinaryExpr(token.LowestPrec + 1)
}
@@ -1261,19 +1261,19 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
defer un(trace(p, "SimpleStmt"))
}
- x := p.parseExprList();
+ x := p.parseExprList()
switch p.tok {
case token.COLON:
// labeled statement
- p.next();
+ p.next()
if labelOk && len(x) == 1 {
if label, isIdent := x[0].(*ast.Ident); isIdent {
return &ast.LabeledStmt{label, p.parseStmt()}
}
}
- p.Error(x[0].Pos(), "illegal label declaration");
- return &ast.BadStmt{x[0].Pos()};
+ p.Error(x[0].Pos(), "illegal label declaration")
+ return &ast.BadStmt{x[0].Pos()}
case
token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
@@ -1281,13 +1281,13 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
// assignment statement
- pos, tok := p.pos, p.tok;
- p.next();
- y := p.parseExprList();
+ pos, tok := p.pos, p.tok
+ p.next()
+ y := p.parseExprList()
if len(x) > 1 && len(y) > 1 && len(x) != len(y) {
p.Error(x[0].Pos(), "arity of lhs doesn't match rhs")
}
- return &ast.AssignStmt{x, pos, tok, y};
+ return &ast.AssignStmt{x, pos, tok, y}
}
if len(x) > 1 {
@@ -1297,23 +1297,23 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
if p.tok == token.INC || p.tok == token.DEC {
// increment or decrement
- s := &ast.IncDecStmt{x[0], p.tok};
- p.next(); // consume "++" or "--"
- return s;
+ s := &ast.IncDecStmt{x[0], p.tok}
+ p.next() // consume "++" or "--"
+ return s
}
// expression
- return &ast.ExprStmt{x[0]};
+ return &ast.ExprStmt{x[0]}
}
func (p *parser) parseCallExpr() *ast.CallExpr {
- x := p.parseExpr();
+ x := p.parseExpr()
if call, isCall := x.(*ast.CallExpr); isCall {
return call
}
- p.errorExpected(x.Pos(), "function/method call");
- return nil;
+ p.errorExpected(x.Pos(), "function/method call")
+ return nil
}
@@ -1322,12 +1322,12 @@ func (p *parser) parseGoStmt() ast.Stmt {
defer un(trace(p, "GoStmt"))
}
- pos := p.expect(token.GO);
- call := p.parseCallExpr();
+ pos := p.expect(token.GO)
+ call := p.parseCallExpr()
if call != nil {
return &ast.GoStmt{pos, call}
}
- return &ast.BadStmt{pos};
+ return &ast.BadStmt{pos}
}
@@ -1336,12 +1336,12 @@ func (p *parser) parseDeferStmt() ast.Stmt {
defer un(trace(p, "DeferStmt"))
}
- pos := p.expect(token.DEFER);
- call := p.parseCallExpr();
+ pos := p.expect(token.DEFER)
+ call := p.parseCallExpr()
if call != nil {
return &ast.DeferStmt{pos, call}
}
- return &ast.BadStmt{pos};
+ return &ast.BadStmt{pos}
}
@@ -1350,14 +1350,14 @@ func (p *parser) parseReturnStmt() *ast.ReturnStmt {
defer un(trace(p, "ReturnStmt"))
}
- pos := p.pos;
- p.expect(token.RETURN);
- var x []ast.Expr;
+ pos := p.pos
+ p.expect(token.RETURN)
+ var x []ast.Expr
if p.tok != token.SEMICOLON && p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE {
x = p.parseExprList()
}
- return &ast.ReturnStmt{pos, x};
+ return &ast.ReturnStmt{pos, x}
}
@@ -1366,13 +1366,13 @@ func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
defer un(trace(p, "BranchStmt"))
}
- s := &ast.BranchStmt{p.pos, tok, nil};
- p.expect(tok);
+ s := &ast.BranchStmt{p.pos, tok, nil}
+ p.expect(tok)
if tok != token.FALLTHROUGH && p.tok == token.IDENT {
s.Label = p.parseIdent()
}
- return s;
+ return s
}
@@ -1383,27 +1383,27 @@ func (p *parser) makeExpr(s ast.Stmt) ast.Expr {
if es, isExpr := s.(*ast.ExprStmt); isExpr {
return p.checkExpr(es.X)
}
- p.Error(s.Pos(), "expected condition, found simple statement");
- return &ast.BadExpr{s.Pos()};
+ p.Error(s.Pos(), "expected condition, found simple statement")
+ return &ast.BadExpr{s.Pos()}
}
func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
if p.tok != token.LBRACE {
- prevLev := p.exprLev;
- p.exprLev = -1;
+ prevLev := p.exprLev
+ p.exprLev = -1
if p.tok != token.SEMICOLON {
s1 = p.parseSimpleStmt(false)
}
if p.tok == token.SEMICOLON {
- p.next();
+ p.next()
if p.tok != token.LBRACE && p.tok != token.SEMICOLON {
s2 = p.parseSimpleStmt(false)
}
if isForStmt {
// for statements have a 3rd section
- p.expect(token.SEMICOLON);
+ p.expect(token.SEMICOLON)
if p.tok != token.LBRACE {
s3 = p.parseSimpleStmt(false)
}
@@ -1412,10 +1412,10 @@ func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
s1, s2 = nil, s1
}
- p.exprLev = prevLev;
+ p.exprLev = prevLev
}
- return s1, s2, s3;
+ return s1, s2, s3
}
@@ -1425,18 +1425,18 @@ func (p *parser) parseIfStmt() *ast.IfStmt {
}
// IfStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.IF);
- s1, s2, _ := p.parseControlClause(false);
- body := p.parseBlockStmt(nil);
- var else_ ast.Stmt;
+ pos := p.expect(token.IF)
+ s1, s2, _ := p.parseControlClause(false)
+ body := p.parseBlockStmt(nil)
+ var else_ ast.Stmt
if p.tok == token.ELSE {
- p.next();
- else_ = p.parseStmt();
+ p.next()
+ else_ = p.parseStmt()
}
- return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_};
+ return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_}
}
@@ -1446,22 +1446,22 @@ func (p *parser) parseCaseClause() *ast.CaseClause {
}
// CaseClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// SwitchCase
- pos := p.pos;
- var x []ast.Expr;
+ pos := p.pos
+ var x []ast.Expr
if p.tok == token.CASE {
- p.next();
- x = p.parseExprList();
+ p.next()
+ x = p.parseExprList()
} else {
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.CaseClause{pos, x, colon, body};
+ return &ast.CaseClause{pos, x, colon, body}
}
@@ -1470,20 +1470,20 @@ func (p *parser) parseTypeList() []ast.Expr {
defer un(trace(p, "TypeList"))
}
- list := new(vector.Vector);
- list.Push(p.parseType());
+ list := new(vector.Vector)
+ list.Push(p.parseType())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseType());
+ p.next()
+ list.Push(p.parseType())
}
// convert list
- exprs := make([]ast.Expr, list.Len());
+ exprs := make([]ast.Expr, list.Len())
for i := 0; i < list.Len(); i++ {
exprs[i] = list.At(i).(ast.Expr)
}
- return exprs;
+ return exprs
}
@@ -1493,22 +1493,22 @@ func (p *parser) parseTypeCaseClause() *ast.TypeCaseClause {
}
// TypeCaseClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// TypeSwitchCase
- pos := p.pos;
- var types []ast.Expr;
+ pos := p.pos
+ var types []ast.Expr
if p.tok == token.CASE {
- p.next();
- types = p.parseTypeList();
+ p.next()
+ types = p.parseTypeList()
} else {
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.TypeCaseClause{pos, types, colon, body};
+ return &ast.TypeCaseClause{pos, types, colon, body}
}
@@ -1518,11 +1518,11 @@ func isExprSwitch(s ast.Stmt) bool {
}
if e, ok := s.(*ast.ExprStmt); ok {
if a, ok := e.X.(*ast.TypeAssertExpr); ok {
- return a.Type != nil // regular type assertion
+ return a.Type != nil // regular type assertion
}
- return true;
+ return true
}
- return false;
+ return false
}
@@ -1532,34 +1532,34 @@ func (p *parser) parseSwitchStmt() ast.Stmt {
}
// SwitchStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.SWITCH);
- s1, s2, _ := p.parseControlClause(false);
+ pos := p.expect(token.SWITCH)
+ s1, s2, _ := p.parseControlClause(false)
if isExprSwitch(s2) {
- lbrace := p.expect(token.LBRACE);
- cases := new(vector.Vector);
+ lbrace := p.expect(token.LBRACE)
+ cases := new(vector.Vector)
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseCaseClause())
}
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
- body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
- return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body};
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
+ body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
+ return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}
}
// type switch
// TODO(gri): do all the checks!
- lbrace := p.expect(token.LBRACE);
- cases := new(vector.Vector);
+ lbrace := p.expect(token.LBRACE)
+ cases := new(vector.Vector)
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseTypeCaseClause())
}
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
- body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
- return &ast.TypeSwitchStmt{pos, s1, s2, body};
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
+ body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
+ return &ast.TypeSwitchStmt{pos, s1, s2, body}
}
@@ -1569,29 +1569,29 @@ func (p *parser) parseCommClause() *ast.CommClause {
}
// CommClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// CommCase
- pos := p.pos;
- var tok token.Token;
- var lhs, rhs ast.Expr;
+ pos := p.pos
+ var tok token.Token
+ var lhs, rhs ast.Expr
if p.tok == token.CASE {
- p.next();
+ p.next()
if p.tok == token.ARROW {
// RecvExpr without assignment
rhs = p.parseExpr()
} else {
// SendExpr or RecvExpr
- rhs = p.parseExpr();
+ rhs = p.parseExpr()
if p.tok == token.ASSIGN || p.tok == token.DEFINE {
// RecvExpr with assignment
- tok = p.tok;
- p.next();
- lhs = rhs;
+ tok = p.tok
+ p.next()
+ lhs = rhs
if p.tok == token.ARROW {
rhs = p.parseExpr()
} else {
- p.expect(token.ARROW) // use expect() error handling
+ p.expect(token.ARROW) // use expect() error handling
}
}
// else SendExpr
@@ -1600,10 +1600,10 @@ func (p *parser) parseCommClause() *ast.CommClause {
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.CommClause{pos, tok, lhs, rhs, colon, body};
+ return &ast.CommClause{pos, tok, lhs, rhs, colon, body}
}
@@ -1612,17 +1612,17 @@ func (p *parser) parseSelectStmt() *ast.SelectStmt {
defer un(trace(p, "SelectStmt"))
}
- pos := p.expect(token.SELECT);
- lbrace := p.expect(token.LBRACE);
- cases := new(vector.Vector);
+ pos := p.expect(token.SELECT)
+ lbrace := p.expect(token.LBRACE)
+ cases := new(vector.Vector)
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseCommClause())
}
- rbrace := p.expect(token.RBRACE);
- p.optSemi = true;
- body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace};
+ rbrace := p.expect(token.RBRACE)
+ p.optSemi = true
+ body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}
- return &ast.SelectStmt{pos, body};
+ return &ast.SelectStmt{pos, body}
}
@@ -1632,49 +1632,49 @@ func (p *parser) parseForStmt() ast.Stmt {
}
// ForStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.FOR);
- s1, s2, s3 := p.parseControlClause(true);
- body := p.parseBlockStmt(nil);
+ pos := p.expect(token.FOR)
+ s1, s2, s3 := p.parseControlClause(true)
+ body := p.parseBlockStmt(nil)
if as, isAssign := s2.(*ast.AssignStmt); isAssign {
// possibly a for statement with a range clause; check assignment operator
if as.Tok != token.ASSIGN && as.Tok != token.DEFINE {
- p.errorExpected(as.TokPos, "'=' or ':='");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.TokPos, "'=' or ':='")
+ return &ast.BadStmt{pos}
}
// check lhs
- var key, value ast.Expr;
+ var key, value ast.Expr
switch len(as.Lhs) {
case 2:
- value = as.Lhs[1];
- fallthrough;
+ value = as.Lhs[1]
+ fallthrough
case 1:
key = as.Lhs[0]
default:
- p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions")
+ return &ast.BadStmt{pos}
}
// check rhs
if len(as.Rhs) != 1 {
- p.errorExpected(as.Rhs[0].Pos(), "1 expressions");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.Rhs[0].Pos(), "1 expressions")
+ return &ast.BadStmt{pos}
}
if rhs, isUnary := as.Rhs[0].(*ast.UnaryExpr); isUnary && rhs.Op == token.RANGE {
// rhs is range expression; check lhs
return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body}
} else {
- p.errorExpected(s2.Pos(), "range clause");
- return &ast.BadStmt{pos};
+ p.errorExpected(s2.Pos(), "range clause")
+ return &ast.BadStmt{pos}
}
} else {
// regular for statement
return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body}
}
- panic(); // unreachable
- return nil;
+ panic() // unreachable
+ return nil
}
@@ -1685,13 +1685,13 @@ func (p *parser) parseStmt() ast.Stmt {
switch p.tok {
case token.CONST, token.TYPE, token.VAR:
- decl, _ := p.parseDecl(false); // do not consume trailing semicolon
- return &ast.DeclStmt{decl};
+ decl, _ := p.parseDecl(false) // do not consume trailing semicolon
+ return &ast.DeclStmt{decl}
case
// tokens that may start a top-level expression
- token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
- token.LBRACK, token.STRUCT, // composite type
- token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
+ token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
+ token.LBRACK, token.STRUCT, // composite type
+ token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
return p.parseSimpleStmt(true)
case token.GO:
return p.parseGoStmt()
@@ -1717,9 +1717,9 @@ func (p *parser) parseStmt() ast.Stmt {
}
// no statement found
- p.errorExpected(p.pos, "statement");
- p.next(); // make progress
- return &ast.BadStmt{p.pos};
+ p.errorExpected(p.pos, "statement")
+ p.next() // make progress
+ return &ast.BadStmt{p.pos}
}
@@ -1734,10 +1734,10 @@ type parseSpecFunction func(p *parser, doc *ast.CommentGroup, getSemi bool) (spe
//
func (p *parser) parseComment(getSemi bool) (comment *ast.CommentGroup, gotSemi bool) {
if getSemi && p.tok == token.SEMICOLON {
- p.next();
- gotSemi = true;
+ p.next()
+ gotSemi = true
}
- return p.lineComment, gotSemi;
+ return p.lineComment, gotSemi
}
@@ -1746,24 +1746,24 @@ func parseImportSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.S
defer un(trace(p, "ImportSpec"))
}
- var ident *ast.Ident;
+ var ident *ast.Ident
if p.tok == token.PERIOD {
- ident = &ast.Ident{p.pos, "."};
- p.next();
+ ident = &ast.Ident{p.pos, "."}
+ p.next()
} else if p.tok == token.IDENT {
ident = p.parseIdent()
}
- var path []*ast.BasicLit;
+ var path []*ast.BasicLit
if p.tok == token.STRING {
path = p.parseStringList(nil)
} else {
- p.expect(token.STRING) // use expect() error handling
+ p.expect(token.STRING) // use expect() error handling
}
- comment, gotSemi := p.parseComment(getSemi);
+ comment, gotSemi := p.parseComment(getSemi)
- return &ast.ImportSpec{doc, ident, path, comment}, gotSemi;
+ return &ast.ImportSpec{doc, ident, path, comment}, gotSemi
}
@@ -1772,16 +1772,16 @@ func parseConstSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Sp
defer un(trace(p, "ConstSpec"))
}
- idents := p.parseIdentList();
- typ := p.tryType();
- var values []ast.Expr;
+ idents := p.parseIdentList()
+ typ := p.tryType()
+ var values []ast.Expr
if typ != nil || p.tok == token.ASSIGN {
- p.expect(token.ASSIGN);
- values = p.parseExprList();
+ p.expect(token.ASSIGN)
+ values = p.parseExprList()
}
- comment, gotSemi := p.parseComment(getSemi);
+ comment, gotSemi := p.parseComment(getSemi)
- return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi;
+ return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi
}
@@ -1790,11 +1790,11 @@ func parseTypeSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spe
defer un(trace(p, "TypeSpec"))
}
- ident := p.parseIdent();
- typ := p.parseType();
- comment, gotSemi := p.parseComment(getSemi);
+ ident := p.parseIdent()
+ typ := p.parseType()
+ comment, gotSemi := p.parseComment(getSemi)
- return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi;
+ return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi
}
@@ -1803,16 +1803,16 @@ func parseVarSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spec
defer un(trace(p, "VarSpec"))
}
- idents := p.parseIdentList();
- typ := p.tryType();
- var values []ast.Expr;
+ idents := p.parseIdentList()
+ typ := p.tryType()
+ var values []ast.Expr
if typ == nil || p.tok == token.ASSIGN {
- p.expect(token.ASSIGN);
- values = p.parseExprList();
+ p.expect(token.ASSIGN)
+ values = p.parseExprList()
}
- comment, gotSemi := p.parseComment(getSemi);
+ comment, gotSemi := p.parseComment(getSemi)
- return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi;
+ return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi
}
@@ -1821,42 +1821,42 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction, getSemi
defer un(trace(p, keyword.String()+"Decl"))
}
- doc := p.leadComment;
- pos := p.expect(keyword);
- var lparen, rparen token.Position;
- list := new(vector.Vector);
+ doc := p.leadComment
+ pos := p.expect(keyword)
+ var lparen, rparen token.Position
+ list := new(vector.Vector)
if p.tok == token.LPAREN {
- lparen = p.pos;
- p.next();
+ lparen = p.pos
+ p.next()
for p.tok != token.RPAREN && p.tok != token.EOF {
- doc := p.leadComment;
- spec, semi := f(p, doc, true); // consume semicolon if any
- list.Push(spec);
+ doc := p.leadComment
+ spec, semi := f(p, doc, true) // consume semicolon if any
+ list.Push(spec)
if !semi {
break
}
}
- rparen = p.expect(token.RPAREN);
+ rparen = p.expect(token.RPAREN)
if getSemi && p.tok == token.SEMICOLON {
- p.next();
- gotSemi = true;
+ p.next()
+ gotSemi = true
} else {
p.optSemi = true
}
} else {
- spec, semi := f(p, nil, getSemi);
- list.Push(spec);
- gotSemi = semi;
+ spec, semi := f(p, nil, getSemi)
+ list.Push(spec)
+ gotSemi = semi
}
// convert vector
- specs := make([]ast.Spec, list.Len());
+ specs := make([]ast.Spec, list.Len())
for i := 0; i < list.Len(); i++ {
specs[i] = list.At(i).(ast.Spec)
}
- return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi;
+ return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi
}
@@ -1865,19 +1865,19 @@ func (p *parser) parseReceiver() *ast.Field {
defer un(trace(p, "Receiver"))
}
- pos := p.pos;
- par := p.parseParameters(false);
+ pos := p.pos
+ par := p.parseParameters(false)
// must have exactly one receiver
if len(par) != 1 || len(par) == 1 && len(par[0].Names) > 1 {
- p.errorExpected(pos, "exactly one receiver");
- return &ast.Field{Type: &ast.BadExpr{noPos}};
+ p.errorExpected(pos, "exactly one receiver")
+ return &ast.Field{Type: &ast.BadExpr{noPos}}
}
- recv := par[0];
+ recv := par[0]
// recv type must be TypeName or *TypeName
- base := recv.Type;
+ base := recv.Type
if ptr, isPtr := base.(*ast.StarExpr); isPtr {
base = ptr.X
}
@@ -1885,7 +1885,7 @@ func (p *parser) parseReceiver() *ast.Field {
p.errorExpected(base.Pos(), "type name")
}
- return recv;
+ return recv
}
@@ -1894,23 +1894,23 @@ func (p *parser) parseFunctionDecl() *ast.FuncDecl {
defer un(trace(p, "FunctionDecl"))
}
- doc := p.leadComment;
- pos := p.expect(token.FUNC);
+ doc := p.leadComment
+ pos := p.expect(token.FUNC)
- var recv *ast.Field;
+ var recv *ast.Field
if p.tok == token.LPAREN {
recv = p.parseReceiver()
}
- ident := p.parseIdent();
- params, results := p.parseSignature();
+ ident := p.parseIdent()
+ params, results := p.parseSignature()
- var body *ast.BlockStmt;
+ var body *ast.BlockStmt
if p.tok == token.LBRACE {
body = p.parseBlockStmt(nil)
}
- return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body};
+ return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}
}
@@ -1919,7 +1919,7 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) {
defer un(trace(p, "Declaration"))
}
- var f parseSpecFunction;
+ var f parseSpecFunction
switch p.tok {
case token.CONST:
f = parseConstSpec
@@ -1931,20 +1931,20 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) {
f = parseVarSpec
case token.FUNC:
- decl = p.parseFunctionDecl();
- _, gotSemi := p.parseComment(getSemi);
- return decl, gotSemi;
+ decl = p.parseFunctionDecl()
+ _, gotSemi := p.parseComment(getSemi)
+ return decl, gotSemi
default:
- pos := p.pos;
- p.errorExpected(pos, "declaration");
- decl = &ast.BadDecl{pos};
- gotSemi = getSemi && p.tok == token.SEMICOLON;
- p.next(); // make progress in any case
- return decl, gotSemi;
+ pos := p.pos
+ p.errorExpected(pos, "declaration")
+ decl = &ast.BadDecl{pos}
+ gotSemi = getSemi && p.tok == token.SEMICOLON
+ p.next() // make progress in any case
+ return decl, gotSemi
}
- return p.parseGenDecl(p.tok, f, getSemi);
+ return p.parseGenDecl(p.tok, f, getSemi)
}
@@ -1953,19 +1953,19 @@ func (p *parser) parseDeclList() []ast.Decl {
defer un(trace(p, "DeclList"))
}
- list := new(vector.Vector);
+ list := new(vector.Vector)
for p.tok != token.EOF {
- decl, _ := p.parseDecl(true); // consume optional semicolon
- list.Push(decl);
+ decl, _ := p.parseDecl(true) // consume optional semicolon
+ list.Push(decl)
}
// convert vector
- decls := make([]ast.Decl, list.Len());
+ decls := make([]ast.Decl, list.Len())
for i := 0; i < list.Len(); i++ {
decls[i] = list.At(i).(ast.Decl)
}
- return decls;
+ return decls
}
@@ -1978,47 +1978,47 @@ func (p *parser) parseFile() *ast.File {
}
// file block
- defer close(openScope(p));
+ defer close(openScope(p))
// package clause
- doc := p.leadComment;
- pos := p.expect(token.PACKAGE);
- ident := p.parseIdent();
+ doc := p.leadComment
+ pos := p.expect(token.PACKAGE)
+ ident := p.parseIdent()
// Common error: semicolon after package clause.
// Accept and report it for better error synchronization.
if p.tok == token.SEMICOLON {
- p.Error(p.pos, "expected declaration, found ';'");
- p.next();
+ p.Error(p.pos, "expected declaration, found ';'")
+ p.next()
}
- var decls []ast.Decl;
+ var decls []ast.Decl
// Don't bother parsing the rest if we had errors already.
// Likely not a Go source file at all.
if p.ErrorCount() == 0 && p.mode&PackageClauseOnly == 0 {
// import decls
- list := new(vector.Vector);
+ list := new(vector.Vector)
for p.tok == token.IMPORT {
- decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true); // consume optional semicolon
- list.Push(decl);
+ decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true) // consume optional semicolon
+ list.Push(decl)
}
if p.mode&ImportsOnly == 0 {
// rest of package body
for p.tok != token.EOF {
- decl, _ := p.parseDecl(true); // consume optional semicolon
- list.Push(decl);
+ decl, _ := p.parseDecl(true) // consume optional semicolon
+ list.Push(decl)
}
}
// convert declaration list
- decls = make([]ast.Decl, list.Len());
+ decls = make([]ast.Decl, list.Len())
for i := 0; i < list.Len(); i++ {
decls[i] = list.At(i).(ast.Decl)
}
}
- return &ast.File{doc, pos, ident, decls, p.comments};
+ return &ast.File{doc, pos, ident, decls, p.comments}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 23:15:52 +0000