// noPos is used when there is no corresponding source position for a token.
-var noPos token.Position;
+var noPos token.Position
// The mode parameter to the Parse* functions is a set of flags (or 0).
// 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 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;
+}
// scannerMode returns the scanner mode bits given the parser's mode bits.
p.ErrorVector.Init();
p.scanner.Init(filename, src, p, scannerMode(mode));
p.mode = mode;
- p.trace = mode & Trace != 0; // for convenience (p.trace is used frequently)
+ p.trace = mode&Trace != 0; // for convenience (p.trace is used frequently)
p.next();
}
// Parsing support
func (p *parser) printTrace(a ...) {
- const dots =
- ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
+ const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";
const n = uint(len(dots));
fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column);
- i := 2*p.indent;
+ i := 2 * p.indent;
for ; i > n; i -= n {
fmt.Print(dots);
}
- fmt.Print(dots[0 : i]);
+ fmt.Print(dots[0:i]);
fmt.Println(a);
}
}
-func un/*trace*/(p *parser) {
+// Usage pattern: defer un(trace(p, "..."));
+func un(p *parser) {
p.indent--;
p.printTrace(")");
}
case p.tok.IsLiteral():
p.printTrace(s, string(p.lit));
case p.tok.IsOperator(), p.tok.IsKeyword():
- p.printTrace("\"" + s + "\"");
+ p.printTrace("\""+s+"\"");
default:
p.printTrace(s);
}
func (p *parser) next() {
p.leadComment = nil;
p.lineComment = nil;
- line := p.pos.Line; // current line
+ line := p.pos.Line; // current line
p.next0();
if p.tok == token.COMMENT {
// make the error message more specific
msg += ", found '" + p.tok.String() + "'";
if p.tok.IsLiteral() {
- msg += " " + string(p.lit);
+ msg += " "+string(p.lit);
}
}
p.Error(pos, msg);
if p.tok != tok {
p.errorExpected(pos, "'" + tok.String() + "'");
}
- p.next(); // make progress in any case
+ p.next(); // make progress in any case
return pos;
}
}
-func close/*Scope*/(p *parser) {
+// Usage pattern: defer close(openScope(p));
+func close(p *parser) {
p.topScope = p.topScope.Outer;
}
p.next();
return x;
}
- p.expect(token.IDENT); // use expect() error handling
+ p.expect(token.IDENT); // use expect() error handling
return &ast.Ident{p.pos, ""};
}
if typ == nil {
p.errorExpected(p.pos, "type");
- p.next(); // make progress
+ p.next(); // make progress
return &ast.BadExpr{p.pos};
}
typ := p.tryParameterType(ellipsisOk);
if typ == nil {
p.errorExpected(p.pos, "type");
- p.next(); // make progress
+ p.next(); // make progress
typ = &ast.BadExpr{p.pos};
}
return typ;
func (p *parser) tryRawType(ellipsisOk bool) ast.Expr {
switch p.tok {
- case token.IDENT: return p.parseTypeName();
- case token.LBRACK: return p.parseArrayType(ellipsisOk);
- case token.STRUCT: return p.parseStructType();
- case token.MUL: return p.parsePointerType();
- case token.FUNC: return p.parseFuncType();
- case token.INTERFACE: return p.parseInterfaceType();
- case token.MAP: return p.parseMapType();
- case token.CHAN, token.ARROW: return p.parseChanType();
+ case token.IDENT:
+ return p.parseTypeName();
+ case token.LBRACK:
+ return p.parseArrayType(ellipsisOk);
+ case token.STRUCT:
+ return p.parseStructType();
+ case token.MUL:
+ return p.parsePointerType();
+ case token.FUNC:
+ return p.parseFuncType();
+ case token.INTERFACE:
+ return p.parseInterfaceType();
+ case token.MAP:
+ return p.parseMapType();
+ case token.CHAN, token.ARROW:
+ return p.parseChanType();
case token.LPAREN:
lparen := p.pos;
p.next();
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;
}
p.exprLev++;
body := p.parseBlockStmt(nil);
- p.optSemi = false; // function body requires separating ";"
+ p.optSemi = false; // function body requires separating ";"
p.exprLev--;
return &ast.FuncLit{typ, body};
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
+ p.next(); // make progress
return &ast.BadExpr{p.pos};
}
switch t := x.(type) {
case *ast.BadExpr:
case *ast.Ident:
- case *ast.ParenExpr: 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
+ case *ast.ParenExpr:
+ 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 true;
}
switch t := x.(type) {
case *ast.BadExpr:
case *ast.Ident:
- case *ast.ParenExpr: return isCompositeLitType(t.X);
- case *ast.SelectorExpr: return isTypeName(t.X);
+ case *ast.ParenExpr:
+ return isCompositeLitType(t.X);
+ case *ast.SelectorExpr:
+ return isTypeName(t.X);
case *ast.ArrayType:
case *ast.StructType:
case *ast.MapType:
- default: return false; // all other nodes are not legal composite literal types
+ default:
+ return false; // all other nodes are not legal composite literal types
}
return true;
}
x := p.parseOperand();
L: for {
switch p.tok {
- case token.PERIOD: x = p.parseSelectorOrTypeAssertion(p.checkExpr(x));
- case token.LBRACK: x = p.parseIndex(p.checkExpr(x));
- case token.LPAREN: x = p.parseCallOrConversion(p.checkExprOrType(x));
+ case token.PERIOD:
+ x = p.parseSelectorOrTypeAssertion(p.checkExpr(x));
+ case token.LBRACK:
+ x = p.parseIndex(p.checkExpr(x));
+ case token.LPAREN:
+ x = p.parseCallOrConversion(p.checkExprOrType(x));
case token.LBRACE:
if isCompositeLitType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
x = p.parseCompositeLit(x);
for p.tok.Precedence() == prec {
pos, op := p.pos, p.tok;
p.next();
- y := p.parseBinaryExpr(prec + 1);
+ y := p.parseBinaryExpr(prec+1);
x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)};
}
}
if p.tok == token.INC || p.tok == token.DEC {
// increment or decrement
s := &ast.IncDecStmt{x[0], p.tok};
- p.next(); // consume "++" or "--"
+ p.next(); // consume "++" or "--"
return s;
}
}
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;
}
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
}
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}
+ return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body};
} else {
p.errorExpected(s2.Pos(), "range clause");
return &ast.BadStmt{pos};
return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body};
}
- panic(); // unreachable
+ panic(); // unreachable
return nil;
}
switch p.tok {
case token.CONST, token.TYPE, token.VAR:
- decl, _ := p.parseDecl(false); // do not consume trailing semicolon
+ 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();
// no statement found
p.errorExpected(p.pos, "statement");
- p.next(); // make progress
+ p.next(); // make progress
return &ast.BadStmt{p.pos};
}
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);
p.next();
for p.tok != token.RPAREN && p.tok != token.EOF {
doc := p.leadComment;
- spec, semi := f(p, doc, true); // consume semicolon if any
+ spec, semi := f(p, doc, true); // consume semicolon if any
list.Push(spec);
if !semi {
break;
p.errorExpected(pos, "declaration");
decl = &ast.BadDecl{pos};
gotSemi = getSemi && p.tok == token.SEMICOLON;
- p.next(); // make progress in any case
+ p.next(); // make progress in any case
return decl, gotSemi;
}
// import decls
list := vector.New(0);
for p.tok == token.IMPORT {
- decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true); // consume optional semicolon
+ 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
+ decl, _ := p.parseDecl(true); // consume optional semicolon
list.Push(decl);
}
}
const /* class */ (
- special = iota;
+ special = iota;
literal;
operator;
keyword;
func tokenclass(tok token.Token) int {
switch {
- case tok.IsLiteral(): return literal;
- case tok.IsOperator(): return operator;
- case tok.IsKeyword(): return keyword;
+ case tok.IsLiteral():
+ return literal;
+ case tok.IsOperator():
+ return operator;
+ case tok.IsKeyword():
+ return keyword;
}
return special;
}
type elt struct {
- tok token.Token;
- lit string;
- class int;
+ tok token.Token;
+ lit string;
+ class int;
}
var tokens = [...]elt{
// Special tokens
- elt{ token.COMMENT, "/* a comment */", special },
- elt{ token.COMMENT, "// a comment \n", special },
+ elt{token.COMMENT, "/* a comment */", special},
+ elt{token.COMMENT, "// a comment \n", special},
// Identifiers and basic type literals
- elt{ token.IDENT, "foobar", literal },
- elt{ token.IDENT, "a۰۱۸", literal },
- elt{ token.IDENT, "foo६४", literal },
- elt{ token.IDENT, "bar９８７６", literal },
- elt{ token.INT, "0", literal },
- elt{ token.INT, "01234567", literal },
- elt{ token.INT, "0xcafebabe", literal },
- elt{ token.FLOAT, "0.", literal },
- elt{ token.FLOAT, ".0", literal },
- elt{ token.FLOAT, "3.14159265", literal },
- elt{ token.FLOAT, "1e0", literal },
- elt{ token.FLOAT, "1e+100", literal },
- elt{ token.FLOAT, "1e-100", literal },
- elt{ token.FLOAT, "2.71828e-1000", literal },
- elt{ token.CHAR, "'a'", literal },
- elt{ token.CHAR, "'\\000'", literal },
- elt{ token.CHAR, "'\\xFF'", literal },
- elt{ token.CHAR, "'\\uff16'", literal },
- elt{ token.CHAR, "'\\U0000ff16'", literal },
- elt{ token.STRING, "`foobar`", literal },
- elt{ token.STRING, "`" `foo
- bar` "`", literal },
+ elt{token.IDENT, "foobar", literal},
+ elt{token.IDENT, "a۰۱۸", literal},
+ elt{token.IDENT, "foo६४", literal},
+ elt{token.IDENT, "bar９８７６", literal},
+ elt{token.INT, "0", literal},
+ elt{token.INT, "01234567", literal},
+ elt{token.INT, "0xcafebabe", literal},
+ elt{token.FLOAT, "0.", literal},
+ elt{token.FLOAT, ".0", literal},
+ elt{token.FLOAT, "3.14159265", literal},
+ elt{token.FLOAT, "1e0", literal},
+ elt{token.FLOAT, "1e+100", literal},
+ elt{token.FLOAT, "1e-100", literal},
+ elt{token.FLOAT, "2.71828e-1000", literal},
+ elt{token.CHAR, "'a'", literal},
+ elt{token.CHAR, "'\\000'", literal},
+ elt{token.CHAR, "'\\xFF'", literal},
+ elt{token.CHAR, "'\\uff16'", literal},
+ elt{token.CHAR, "'\\U0000ff16'", literal},
+ elt{token.STRING, "`foobar`", literal},
+ elt{token.STRING, "`" `foo
+ bar`
+ "`",
+ literal,
+ },
// Operators and delimitors
- elt{ token.ADD, "+", operator },
- elt{ token.SUB, "-", operator },
- elt{ token.MUL, "*", operator },
- elt{ token.QUO, "/", operator },
- elt{ token.REM, "%", operator },
-
- elt{ token.AND, "&", operator },
- elt{ token.OR, "|", operator },
- elt{ token.XOR, "^", operator },
- elt{ token.SHL, "<<", operator },
- elt{ token.SHR, ">>", operator },
- elt{ token.AND_NOT, "&^", operator },
-
- elt{ token.ADD_ASSIGN, "+=", operator },
- elt{ token.SUB_ASSIGN, "-=", operator },
- elt{ token.MUL_ASSIGN, "*=", operator },
- elt{ token.QUO_ASSIGN, "/=", operator },
- elt{ token.REM_ASSIGN, "%=", operator },
-
- elt{ token.AND_ASSIGN, "&=", operator },
- elt{ token.OR_ASSIGN, "|=", operator },
- elt{ token.XOR_ASSIGN, "^=", operator },
- elt{ token.SHL_ASSIGN, "<<=", operator },
- elt{ token.SHR_ASSIGN, ">>=", operator },
- elt{ token.AND_NOT_ASSIGN, "&^=", operator },
-
- elt{ token.LAND, "&&", operator },
- elt{ token.LOR, "||", operator },
- elt{ token.ARROW, "<-", operator },
- elt{ token.INC, "++", operator },
- elt{ token.DEC, "--", operator },
-
- elt{ token.EQL, "==", operator },
- elt{ token.LSS, "<", operator },
- elt{ token.GTR, ">", operator },
- elt{ token.ASSIGN, "=", operator },
- elt{ token.NOT, "!", operator },
-
- elt{ token.NEQ, "!=", operator },
- elt{ token.LEQ, "<=", operator },
- elt{ token.GEQ, ">=", operator },
- elt{ token.DEFINE, ":=", operator },
- elt{ token.ELLIPSIS, "...", operator },
-
- elt{ token.LPAREN, "(", operator },
- elt{ token.LBRACK, "[", operator },
- elt{ token.LBRACE, "{", operator },
- elt{ token.COMMA, ",", operator },
- elt{ token.PERIOD, ".", operator },
-
- elt{ token.RPAREN, ")", operator },
- elt{ token.RBRACK, "]", operator },
- elt{ token.RBRACE, "}", operator },
- elt{ token.SEMICOLON, ";", operator },
- elt{ token.COLON, ":", operator },
+ elt{token.ADD, "+", operator},
+ elt{token.SUB, "-", operator},
+ elt{token.MUL, "*", operator},
+ elt{token.QUO, "/", operator},
+ elt{token.REM, "%", operator},
+
+ elt{token.AND, "&", operator},
+ elt{token.OR, "|", operator},
+ elt{token.XOR, "^", operator},
+ elt{token.SHL, "<<", operator},
+ elt{token.SHR, ">>", operator},
+ elt{token.AND_NOT, "&^", operator},
+
+ elt{token.ADD_ASSIGN, "+=", operator},
+ elt{token.SUB_ASSIGN, "-=", operator},
+ elt{token.MUL_ASSIGN, "*=", operator},
+ elt{token.QUO_ASSIGN, "/=", operator},
+ elt{token.REM_ASSIGN, "%=", operator},
+
+ elt{token.AND_ASSIGN, "&=", operator},
+ elt{token.OR_ASSIGN, "|=", operator},
+ elt{token.XOR_ASSIGN, "^=", operator},
+ elt{token.SHL_ASSIGN, "<<=", operator},
+ elt{token.SHR_ASSIGN, ">>=", operator},
+ elt{token.AND_NOT_ASSIGN, "&^=", operator},
+
+ elt{token.LAND, "&&", operator},
+ elt{token.LOR, "||", operator},
+ elt{token.ARROW, "<-", operator},
+ elt{token.INC, "++", operator},
+ elt{token.DEC, "--", operator},
+
+ elt{token.EQL, "==", operator},
+ elt{token.LSS, "<", operator},
+ elt{token.GTR, ">", operator},
+ elt{token.ASSIGN, "=", operator},
+ elt{token.NOT, "!", operator},
+
+ elt{token.NEQ, "!=", operator},
+ elt{token.LEQ, "<=", operator},
+ elt{token.GEQ, ">=", operator},
+ elt{token.DEFINE, ":=", operator},
+ elt{token.ELLIPSIS, "...", operator},
+
+ elt{token.LPAREN, "(", operator},
+ elt{token.LBRACK, "[", operator},
+ elt{token.LBRACE, "{", operator},
+ elt{token.COMMA, ",", operator},
+ elt{token.PERIOD, ".", operator},
+
+ elt{token.RPAREN, ")", operator},
+ elt{token.RBRACK, "]", operator},
+ elt{token.RBRACE, "}", operator},
+ elt{token.SEMICOLON, ";", operator},
+ elt{token.COLON, ":", operator},
// Keywords
- elt{ token.BREAK, "break", keyword },
- elt{ token.CASE, "case", keyword },
- elt{ token.CHAN, "chan", keyword },
- elt{ token.CONST, "const", keyword },
- elt{ token.CONTINUE, "continue", keyword },
-
- elt{ token.DEFAULT, "default", keyword },
- elt{ token.DEFER, "defer", keyword },
- elt{ token.ELSE, "else", keyword },
- elt{ token.FALLTHROUGH, "fallthrough", keyword },
- elt{ token.FOR, "for", keyword },
-
- elt{ token.FUNC, "func", keyword },
- elt{ token.GO, "go", keyword },
- elt{ token.GOTO, "goto", keyword },
- elt{ token.IF, "if", keyword },
- elt{ token.IMPORT, "import", keyword },
-
- elt{ token.INTERFACE, "interface", keyword },
- elt{ token.MAP, "map", keyword },
- elt{ token.PACKAGE, "package", keyword },
- elt{ token.RANGE, "range", keyword },
- elt{ token.RETURN, "return", keyword },
-
- elt{ token.SELECT, "select", keyword },
- elt{ token.STRUCT, "struct", keyword },
- elt{ token.SWITCH, "switch", keyword },
- elt{ token.TYPE, "type", keyword },
- elt{ token.VAR, "var", keyword },
+ elt{token.BREAK, "break", keyword},
+ elt{token.CASE, "case", keyword},
+ elt{token.CHAN, "chan", keyword},
+ elt{token.CONST, "const", keyword},
+ elt{token.CONTINUE, "continue", keyword},
+
+ elt{token.DEFAULT, "default", keyword},
+ elt{token.DEFER, "defer", keyword},
+ elt{token.ELSE, "else", keyword},
+ elt{token.FALLTHROUGH, "fallthrough", keyword},
+ elt{token.FOR, "for", keyword},
+
+ elt{token.FUNC, "func", keyword},
+ elt{token.GO, "go", keyword},
+ elt{token.GOTO, "goto", keyword},
+ elt{token.IF, "if", keyword},
+ elt{token.IMPORT, "import", keyword},
+
+ elt{token.INTERFACE, "interface", keyword},
+ elt{token.MAP, "map", keyword},
+ elt{token.PACKAGE, "package", keyword},
+ elt{token.RANGE, "range", keyword},
+ elt{token.RETURN, "return", keyword},
+
+ elt{token.SELECT, "select", keyword},
+ elt{token.STRUCT, "struct", keyword},
+ elt{token.SWITCH, "switch", keyword},
+ elt{token.TYPE, "type", keyword},
+ elt{token.VAR, "var", keyword},
}
-const whitespace = " \t \n\n\n"; // to separate tokens
+const whitespace = " \t \n\n\n" // to separate tokens
type TestErrorHandler struct {
- t *testing.T
+ t *testing.T;
}
func (h *TestErrorHandler) Error(pos token.Position, msg string) {
if pos.Line != expected.Line {
t.Errorf("bad line for %s: got %d, expected %d", lit, pos.Line, expected.Line);
}
- if pos.Column!= expected.Column {
+ if pos.Column != expected.Column {
t.Errorf("bad column for %s: got %d, expected %d", lit, pos.Column, expected.Column);
}
}
index := 0;
epos := token.Position{"", 0, 1, 1};
nerrors := Tokenize("", strings.Bytes(src), &TestErrorHandler{t}, ScanComments,
- func (pos token.Position, tok token.Token, litb []byte) bool {
+ func(pos token.Position, tok token.Token, litb []byte) bool {
e := elt{token.EOF, "", special};
if index < len(tokens) {
e = tokens[index];
if tokenclass(tok) != e.class {
t.Errorf("bad class for %s: got %d, expected %d", lit, tokenclass(tok), e.class);
}
- epos.Offset += len(lit) + len(whitespace);
+ epos.Offset += len(lit)+len(whitespace);
epos.Line += NewlineCount(lit) + whitespace_linecount;
if tok == token.COMMENT && litb[1] == '/' {
// correct for unaccounted '/n' in //-style comment
}
index++;
return tok != token.EOF;
- }
- );
+ });
if nerrors != 0 {
t.Errorf("found %d errors", nerrors);
}
type seg struct {
- srcline string; // a line of source text
- filename string; // filename for current token
- line int; // line number for current token
+ srcline string; // a line of source text
+ filename string; // filename for current token
+ line int; // line number for current token
}
var segments = []seg{
// exactly one token per line since the test consumes one token per segment
- seg{ " line1", "TestLineComments", 1 },
- seg{ "\nline2", "TestLineComments", 2 },
- seg{ "\nline3 //line File1.go:100", "TestLineComments", 3 }, // bad line comment, ignored
- seg{ "\nline4", "TestLineComments", 4 },
- seg{ "\n//line File1.go:100\n line100", "File1.go", 100 },
- seg{ "\n//line File2.go:200\n line200", "File2.go", 200 },
- seg{ "\n//line :1\n line1", "", 1 },
- seg{ "\n//line foo:42\n line42", "foo", 42 },
- seg{ "\n //line foo:42\n line44", "foo", 44 }, // bad line comment, ignored
- seg{ "\n//line foo 42\n line46", "foo", 46 }, // bad line comment, ignored
- seg{ "\n//line foo:42 extra text\n line48", "foo", 48 }, // bad line comment, ignored
- seg{ "\n//line foo:42\n line42", "foo", 42 },
- seg{ "\n//line foo:42\n line42", "foo", 42 },
- seg{ "\n//line File1.go:100\n line100", "File1.go", 100 },
+ seg{" line1", "TestLineComments", 1},
+ seg{"\nline2", "TestLineComments", 2},
+ seg{"\nline3 //line File1.go:100", "TestLineComments", 3}, // bad line comment, ignored
+ seg{"\nline4", "TestLineComments", 4},
+ seg{"\n//line File1.go:100\n line100", "File1.go", 100},
+ seg{"\n//line File2.go:200\n line200", "File2.go", 200},
+ seg{"\n//line :1\n line1", "", 1},
+ seg{"\n//line foo:42\n line42", "foo", 42},
+ seg{"\n //line foo:42\n line44", "foo", 44}, // bad line comment, ignored
+ seg{"\n//line foo 42\n line46", "foo", 46}, // bad line comment, ignored
+ seg{"\n//line foo:42 extra text\n line48", "foo", 48}, // bad line comment, ignored
+ seg{"\n//line foo:42\n line42", "foo", 42},
+ seg{"\n//line foo:42\n line42", "foo", 42},
+ seg{"\n//line File1.go:100\n line100", "File1.go", 100},
}
// 1st init
s.Init("", strings.Bytes("if true { }"), nil, 0);
- s.Scan(); // if
- s.Scan(); // true
- _, tok, _ := s.Scan(); // {
+ s.Scan(); // if
+ s.Scan(); // true
+ _, tok, _ := s.Scan(); // {
if tok != token.LBRACE {
t.Errorf("bad token: got %s, expected %s", tok.String(), token.LBRACE);
}
// 2nd init
s.Init("", strings.Bytes("go true { ]"), nil, 0);
- _, tok, _ = s.Scan(); // go
+ _, tok, _ = s.Scan(); // go
if tok != token.GO {
t.Errorf("bad token: got %s, expected %s", tok.String(), token.GO);
}
func TestStdErrorHander(t *testing.T) {
- const src =
- "@\n" // illegal character, cause an error
- "@ @\n" // two errors on the same line
+ const src = "@\n" // illegal character, cause an error
+ "@ @\n" // two errors on the same line
"//line File2:20\n"
- "@\n" // different file, but same line
+ "@\n" // different file, but same line
"//line File2:1\n"
- "@ @\n" // same file, decreasing line number
+ "@ @\n" // same file, decreasing line number
"//line File1:1\n"
- "@ @ @" // original file, line 1 again
- ;
+ "@ @ @"; // original file, line 1 again
+
v := NewErrorVector();
nerrors := Tokenize("File1", strings.Bytes(src), v, 0,
- func (pos token.Position, tok token.Token, litb []byte) bool {
- return tok != token.EOF;
- }
- );
+ func(pos token.Position, tok token.Token, litb []byte) bool { return tok != token.EOF });
list := v.GetErrorList(Raw);
if len(list) != 9 {