"strings"
)
-const trace = true // if set, parse tracing can be enabled with -x
+const trace = false // if set, parse tracing can be enabled with -x
// TODO(gri) Once we handle imports w/o redirecting the underlying
// source of the lexer we can get rid of these. They are here for
}
func parse_file() {
- // This doesn't quite work w/ the trybots. Fun experiment but we need to find a better way.
- // go func() {
- // prev := lexlineno
- // for {
- // time.Sleep(5 * time.Second)
- // t := lexlineno // racy but we don't care - any new value will do
- // if prev == t {
- // // If lexlineno doesn't change anymore we probably have an endless
- // // loop somewhere. Terminate before process becomes unresponsive.
- // Yyerror("internal error: compiler makes no progress (workaround: -oldparser)")
- // errorexit()
- // }
- // prev = t
- // }
- // }()
-
thenewparser = parser{}
thenewparser.loadsys()
thenewparser.next()
func (p *parser) want(tok int32) {
if p.tok != EOF && !p.got(tok) {
- p.error("")
+ p.syntax_error("")
+ p.advance()
}
}
// ----------------------------------------------------------------------------
// Syntax error handling
-// TODO(gri) Approach this more systematically. For now it passes all tests.
-
-func syntax_error(msg string) {
- Yyerror("syntax error: " + msg)
-}
+func (p *parser) syntax_error(msg string) {
+ if p.tok == EOF && nerrors > 0 {
+ return // avoid meaningless follow-up errors
+ }
-func (p *parser) error(context string) {
- if p.tok == EOF {
+ // add punctuation etc. as needed to msg
+ switch {
+ case msg == "":
+ // nothing to do
+ case strings.HasPrefix(msg, "in"), strings.HasPrefix(msg, "at"), strings.HasPrefix(msg, "after"):
+ msg = " " + msg
+ case strings.HasPrefix(msg, "expecting"):
+ msg = ", " + msg
+ default:
+ // plain error - we don't care about current token
+ Yyerror("syntax error: " + msg)
return
}
- syntax_error("unexpected " + tokstring(p.tok) + context)
- // TODO(gri) keep also track of nesting below
+
+ // determine token string
+ var tok string
switch p.tok {
- case '(':
- // skip to closing ')'
- for p.tok != EOF && p.tok != ')' {
- p.next()
+ case LLITERAL:
+ // this is also done in Yyerror but it's cleaner to do it here
+ tok = litbuf
+ case LNAME:
+ if p.sym_ != nil && p.sym_.Name != "" {
+ tok = p.sym_.Name
+ } else {
+ tok = "name"
}
- case '{':
- // skip to closing '}'
- for p.tok != EOF && p.tok != '}' {
- p.next()
+ case LASOP:
+ tok = goopnames[p.op] + "="
+ default:
+ tok = tokstring(p.tok)
+ }
+
+ Yyerror("syntax error: unexpected " + tok + msg)
+}
+
+// Advance consumes tokens until it finds one in the stoplist.
+// If the stoplist is empty, the next token is consumed.
+func (p *parser) advance(stoplist ...int32) {
+ if len(stoplist) == 0 {
+ p.next()
+ return
+ }
+
+ for p.tok != EOF {
+ for _, stop := range stoplist {
+ if p.tok == stop {
+ return
+ }
}
+ p.next()
}
- p.next() // make progress
}
func tokstring(tok int32) string {
LIMPORT: "import",
LINTERFACE: "interface",
LMAP: "map",
- LNAME: "<name>",
+ LNAME: "LNAME",
LPACKAGE: "package",
LRANGE: "range",
LRETURN: "return",
mkpackage(p.sym().Name)
p.want(';')
} else {
- prevlineno = lineno // TODO(gri) do we still need this? (e.g., not needed for test/fixedbugs/bug050.go)
- Yyerror("package statement must be first")
+ p.syntax_error("package statement must be first")
errorexit()
}
}
-// import:
-// LIMPORT import_stmt
-// | LIMPORT '(' import_stmt_list osemi ')'
-// | LIMPORT '(' ')'
-
+// go.y:import
func (p *parser) import_() {
if trace && Debug['x'] != 0 {
defer p.trace("import_")()
path = p.val
p.next()
} else {
- syntax_error("missing import path; require quoted string")
+ p.syntax_error("missing import path; require quoted string")
+ p.advance(';', ')')
}
line := parserline() // TODO(gri) check correct placement of this
if p.tok != ';' {
typ = p.ntype()
} else {
- p.error(" in type declaration")
+ p.syntax_error("in type declaration")
+ p.advance(';', ')')
}
return list1(typedcl1(name, typ, true))
if lhs.Op == ONAME || lhs.Op == ONONAME || lhs.Op == OTYPE {
lhs = newname(lhs.Sym)
} else {
- p.error(", expecting semicolon or newline or }")
+ p.syntax_error("expecting semicolon or newline or }")
+ // we already progressed, no need to advance
}
lhs := Nod(OLABEL, lhs, nil)
lhs.Sym = dclstack // context, for goto restrictions
rhs := p.expr_list()
if rhs.N.Op == OTYPESW {
- ss := Nod(OTYPESW, nil, rhs.N.Right)
+ ts := Nod(OTYPESW, nil, rhs.N.Right)
if rhs.Next != nil {
Yyerror("expr.(type) must be alone in list")
}
} else if (lhs.N.Op != ONAME && lhs.N.Op != OTYPE && lhs.N.Op != ONONAME && (lhs.N.Op != OLITERAL || lhs.N.Name == nil)) || isblank(lhs.N) {
Yyerror("invalid variable name %s in type switch", lhs.N)
} else {
- ss.Left = dclname(lhs.N.Sym)
- } // it's a colas, so must not re-use an oldname.
- return ss
+ ts.Left = dclname(lhs.N.Sym)
+ } // it's a colas, so must not re-use an oldname
+ return ts
}
return colas(lhs, rhs, int32(line))
default:
- p.error(", expecting := or = or comma")
+ p.syntax_error("expecting := or = or comma")
+ p.advance(';', '}')
return nil
}
}
// report error at line of ':' token
saved := lexlineno
lexlineno = prevlineno
- syntax_error("missing statement after label")
+ p.syntax_error("missing statement after label")
+ // we are already at the end of the labeled statement - no need to advance
lexlineno = saved
return missing_stmt
}
return stmt
default:
- p.error(", expecting := or = or : or comma")
+ p.syntax_error("expecting := or = or : or comma")
+ p.advance(LCASE, LDEFAULT, '}')
return nil
}
return stmt
default:
- p.error(", expecting case or default or }")
+ p.syntax_error("expecting case or default or }")
+ p.advance(LCASE, LDEFAULT, '}')
return nil
}
}
markdcl()
p.next() // consume ';' after markdcl() for correct lineno
} else if else_clause {
- syntax_error("else must be followed by if or statement block")
- // skip through closing }
- for p.tok != EOF && p.tok != '}' {
- p.next()
- }
- p.next()
+ p.syntax_error("else must be followed by if or statement block")
+ p.advance('}')
return nil
} else {
panic("unreachable")
}
if !p.got('{') {
- syntax_error("missing { after switch clause")
- // skip through closing }
- for p.tok != EOF && p.tok != '}' {
- p.next()
- }
- p.next()
+ p.syntax_error("missing { after switch clause")
+ p.advance('}')
return nil
}
markdcl()
p.next() // consume ';' after markdcl() for correct lineno
} else {
- syntax_error("missing { after " + context)
- // skip through closing }
- for p.tok != EOF && p.tok != '}' {
- p.next()
- }
- p.next()
+ p.syntax_error("missing { after " + context)
+ p.advance('}')
return nil
}
case '{':
// common case: p.header is missing simple_stmt before { in if, for, switch
- syntax_error("missing operand")
+ p.syntax_error("missing operand")
// '{' will be consumed in pexpr - no need to consume it here
return nil
default:
- p.error(" in operand")
+ p.syntax_error("in operand")
+ p.advance(';', '}')
return nil
}
}
}
default:
- p.error(", expecting name or (")
+ p.syntax_error("expecting name or (")
+ p.advance(';', '}')
}
case '[':
break loop
}
if t != x {
- syntax_error("cannot parenthesize type in composite literal")
+ p.syntax_error("cannot parenthesize type in composite literal")
+ // already progressed, no need to advance
}
n := p.complitexpr()
n.Right = x
return nil
default:
- p.error("")
+ p.syntax_error("")
+ p.advance()
return new(Sym)
}
}
case LDDD:
// permit ...T but complain
// TODO(gri) introduced for test/fixedbugs/bug228.go - maybe adjust bug or find better solution
- p.error(" in type")
+ p.syntax_error("")
+ p.advance()
return p.ntype()
default:
- p.error(" in type")
+ p.syntax_error("")
+ p.advance()
return nil
}
}
LDDD:
return p.ntype()
default:
- syntax_error("missing channel element type")
+ p.syntax_error("missing channel element type")
+ // assume element type is simply absent - don't advance
return nil
}
}
return f
default:
- p.error(", expecting name or (")
+ p.syntax_error("expecting name or (")
+ p.advance('{', ';')
return nil
}
}
default:
if p.tok == '{' && l != nil && l.End.N.Op == ODCLFUNC && l.End.N.Nbody == nil {
// opening { of function declaration on next line
- syntax_error("unexpected semicolon or newline before {")
+ p.syntax_error("unexpected semicolon or newline before {")
} else {
- syntax_error("non-declaration statement outside function body")
- }
- // skip over tokens until we find a new top-level declaration
- // TODO(gri) keep track of {} nesting as well?
- for {
- p.next()
- switch p.tok {
- case LVAR, LCONST, LTYPE, LFUNC, EOF:
- continue loop
- }
+ p.syntax_error("non-declaration statement outside function body")
}
-
+ p.advance(LVAR, LCONST, LTYPE, LFUNC)
+ goto loop
}
if nsyntaxerrors == 0 {
// it may read the subsequent comment line which may
// set the flags for the next function declaration.
if p.tok != EOF && !p.got(';') {
- p.error(" after top level declaration")
- // TODO(gri) same code above - factor!
- for {
- p.next()
- switch p.tok {
- case LVAR, LCONST, LTYPE, LFUNC, EOF:
- continue loop
- }
- }
+ p.syntax_error("after top level declaration")
+ p.advance(LVAR, LCONST, LTYPE, LFUNC)
+ goto loop
}
}
return
}
default:
- p.error(", expecting field name or embedded type")
+ p.syntax_error("expecting field name or embedded type")
+ p.advance(';', '}')
return nil
}
}
name = p.sym_
p.next()
} else {
- p.error(", expecting name")
+ p.syntax_error("expecting name")
+ p.advance('.', ';', '}')
name = new(Sym)
}
hasNameList = true
}
if hasNameList {
- syntax_error("name list not allowed in interface type")
+ p.syntax_error("name list not allowed in interface type")
+ // already progressed, no need to advance
}
if p.tok != '(' {
return n
default:
- p.error("")
+ p.syntax_error("")
+ p.advance(';', '}')
return nil
}
}
return p.ntype()
default:
- p.error(", expecting )")
+ p.syntax_error("expecting )")
+ p.advance(',', ')')
return nil
}
}
continue
}
if !p.got(';') {
- p.error(" at end of statement")
+ p.syntax_error("at end of statement")
+ p.advance(';', '}')
}
}
return
// ',' is optional before a closing ')' or '}'
return
case ';':
- syntax_error("need trailing comma before newline in " + context)
- p.next()
+ p.syntax_error("need trailing comma before newline in " + context)
+ p.next() // interpret ';' as comma
return
}
p.want(',')
// Importing packages
func (p *parser) import_error() {
- p.error(" in export data of imported package")
+ p.syntax_error("in export data of imported package")
+ p.next()
}
// The methods below reflect a 1:1 translation of the corresponding go.y yacc