2008-07-07 18:27:14 -06:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package Parser
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
//import . "scanner"
|
2008-07-07 18:27:14 -06:00
|
|
|
import Scanner "scanner"
|
|
|
|
|
|
|
|
|
|
|
|
export Parser
|
|
|
|
type Parser struct {
|
2008-07-08 17:39:04 -06:00
|
|
|
verbose, indent int;
|
2008-07-07 18:27:14 -06:00
|
|
|
S *Scanner.Scanner;
|
|
|
|
tok int; // one token look-ahead
|
|
|
|
beg, end int; // token position
|
2008-07-08 17:39:04 -06:00
|
|
|
ident string; // last ident seen
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) PrintIndent() {
|
|
|
|
for i := P.indent; i > 0; i-- {
|
|
|
|
print " ";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) Trace(msg string) {
|
|
|
|
if P.verbose > 0 {
|
|
|
|
P.PrintIndent();
|
|
|
|
print msg, " {\n";
|
|
|
|
P.indent++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) Ecart() {
|
|
|
|
if P.verbose > 0 {
|
|
|
|
P.indent--;
|
|
|
|
P.PrintIndent();
|
|
|
|
print "}\n";
|
|
|
|
}
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) Next() {
|
2008-07-08 17:39:04 -06:00
|
|
|
P.tok, P.beg, P.end = P.S.Scan();
|
|
|
|
if P.tok == Scanner.IDENT {
|
|
|
|
P.ident = P.S.src[P.beg : P.end];
|
|
|
|
}
|
|
|
|
if P.verbose > 1 {
|
|
|
|
P.PrintIndent();
|
|
|
|
print Scanner.TokenName(P.tok), "\n";
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 17:39:04 -06:00
|
|
|
func (P *Parser) Open(S *Scanner.Scanner, verbose int) {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.verbose = verbose;
|
2008-07-08 17:39:04 -06:00
|
|
|
P.indent = 0;
|
2008-07-07 18:27:14 -06:00
|
|
|
P.S = S;
|
|
|
|
P.Next();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) Error(msg string) {
|
2008-07-08 17:39:04 -06:00
|
|
|
panic "error: ", msg, "\n";
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next(); // make progress
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) Expect(tok int) {
|
2008-07-08 19:37:31 -06:00
|
|
|
if P.tok == tok {
|
|
|
|
P.Next()
|
|
|
|
} else {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Error("expected `" + Scanner.TokenName(tok) + "`, found `" + Scanner.TokenName(P.tok) + "`");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) Optional(tok int) {
|
|
|
|
if P.tok == tok {
|
|
|
|
P.Next();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) TryType() bool;
|
2008-07-07 18:27:14 -06:00
|
|
|
func (P *Parser) ParseExpression();
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseIdent() {
|
2008-07-08 17:39:04 -06:00
|
|
|
if P.verbose > 0 {
|
|
|
|
P.PrintIndent();
|
|
|
|
print "Ident = \"", P.ident, "\"\n";
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Expect(Scanner.IDENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseIdentList() {
|
|
|
|
P.Trace("IdentList");
|
|
|
|
P.ParseIdent();
|
|
|
|
for P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParseIdent();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseQualifiedIdent() {
|
|
|
|
P.Trace("QualifiedIdent");
|
|
|
|
P.ParseIdent();
|
|
|
|
if P.tok == Scanner.PERIOD {
|
|
|
|
P.Next();
|
|
|
|
P.ParseIdent();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseTypeName() {
|
|
|
|
P.Trace("TypeName");
|
|
|
|
P.ParseQualifiedIdent();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) ParseType() {
|
|
|
|
P.Trace("Type");
|
|
|
|
if !P.TryType() {
|
|
|
|
P.Error("type expected");
|
|
|
|
}
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-07 18:27:14 -06:00
|
|
|
func (P *Parser) ParseArrayType() {
|
|
|
|
P.Trace("ArrayType");
|
|
|
|
P.Expect(Scanner.LBRACK);
|
|
|
|
if P.tok != Scanner.RBRACK {
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RBRACK);
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseChannelType() {
|
|
|
|
P.Trace("ChannelType");
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Expect(Scanner.CHAN);
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.LSS: fallthrough
|
|
|
|
case Scanner.GTR:
|
|
|
|
P.Next();
|
|
|
|
}
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseInterfaceType() {
|
|
|
|
P.Trace("InterfaceType");
|
2008-07-08 17:39:04 -06:00
|
|
|
panic "InterfaceType";
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseFunctionType() {
|
|
|
|
P.Trace("FunctionType");
|
2008-07-08 17:39:04 -06:00
|
|
|
panic "FunctionType";
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseMapType() {
|
|
|
|
P.Trace("MapType");
|
|
|
|
P.Expect(Scanner.MAP);
|
|
|
|
P.Expect(Scanner.LBRACK);
|
|
|
|
P.ParseType();
|
|
|
|
P.Expect(Scanner.RBRACK);
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseFieldDecl() {
|
|
|
|
P.Trace("FieldDecl");
|
|
|
|
P.ParseIdentList();
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseStructType() {
|
|
|
|
P.Trace("StructType");
|
|
|
|
P.Expect(Scanner.STRUCT);
|
|
|
|
P.Expect(Scanner.LBRACE);
|
2008-07-08 17:39:04 -06:00
|
|
|
for P.tok != Scanner.RBRACE {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseFieldDecl();
|
2008-07-08 17:39:04 -06:00
|
|
|
if P.tok != Scanner.RBRACE {
|
|
|
|
P.Expect(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
}
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Expect(Scanner.RBRACE);
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParsePointerType() {
|
|
|
|
P.Trace("PointerType");
|
|
|
|
P.Expect(Scanner.MUL);
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) TryType() bool {
|
|
|
|
P.Trace("Type (try)");
|
2008-07-07 18:27:14 -06:00
|
|
|
switch P.tok {
|
|
|
|
case Scanner.IDENT:
|
|
|
|
P.ParseTypeName();
|
|
|
|
case Scanner.LBRACK:
|
|
|
|
P.ParseArrayType();
|
|
|
|
case Scanner.CHAN:
|
|
|
|
P.ParseChannelType();
|
|
|
|
case Scanner.INTERFACE:
|
|
|
|
P.ParseInterfaceType();
|
|
|
|
case Scanner.FUNC:
|
|
|
|
P.ParseFunctionType();
|
|
|
|
case Scanner.MAP:
|
|
|
|
P.ParseMapType();
|
|
|
|
case Scanner.STRUCT:
|
|
|
|
P.ParseStructType();
|
|
|
|
case Scanner.MUL:
|
|
|
|
P.ParsePointerType();
|
|
|
|
default:
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Ecart();
|
|
|
|
return false;
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-08 19:37:31 -06:00
|
|
|
return true;
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseImportSpec() {
|
|
|
|
P.Trace("ImportSpec");
|
|
|
|
if P.tok == Scanner.PERIOD {
|
|
|
|
P.Next();
|
|
|
|
} else if P.tok == Scanner.IDENT {
|
|
|
|
P.Next();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.STRING);
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseImportDecl() {
|
|
|
|
P.Trace("ImportDecl");
|
|
|
|
P.Expect(Scanner.IMPORT);
|
|
|
|
if P.tok == Scanner.LPAREN {
|
2008-07-09 11:16:33 -06:00
|
|
|
P.Next();
|
|
|
|
for P.tok != Scanner.RPAREN {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseImportSpec();
|
2008-07-09 11:16:33 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON); // TODO this seems wrong
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-09 11:16:33 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
} else {
|
|
|
|
P.ParseImportSpec();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseExpressionList() {
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Trace("ExpressionList");
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseExpression();
|
|
|
|
for P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseConstSpec() {
|
|
|
|
P.Trace("ConstSpec");
|
|
|
|
P.ParseIdent();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.TryType();
|
2008-07-07 18:27:14 -06:00
|
|
|
if P.tok == Scanner.ASSIGN {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseConstDecl() {
|
|
|
|
P.Trace("ConstDecl");
|
|
|
|
P.Expect(Scanner.CONST);
|
|
|
|
if P.tok == Scanner.LPAREN {
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
|
|
|
for P.tok != Scanner.RPAREN {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseConstSpec();
|
2008-07-08 19:37:31 -06:00
|
|
|
if P.tok != Scanner.RPAREN {
|
|
|
|
P.Expect(Scanner.SEMICOLON);
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
} else {
|
|
|
|
P.ParseConstSpec();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseTypeSpec() {
|
|
|
|
P.Trace("TypeSpec");
|
|
|
|
P.ParseIdent();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.TryType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseTypeDecl() {
|
|
|
|
P.Trace("TypeDecl");
|
|
|
|
P.Expect(Scanner.TYPE);
|
|
|
|
if P.tok == Scanner.LPAREN {
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
|
|
|
for P.tok != Scanner.RPAREN {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseTypeSpec();
|
2008-07-08 19:37:31 -06:00
|
|
|
if P.tok != Scanner.RPAREN {
|
|
|
|
P.Expect(Scanner.SEMICOLON);
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
} else {
|
|
|
|
P.ParseTypeSpec();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseVarSpec() {
|
|
|
|
P.Trace("VarSpec");
|
|
|
|
P.ParseIdentList();
|
|
|
|
if P.tok == Scanner.ASSIGN {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpressionList();
|
|
|
|
} else {
|
|
|
|
P.ParseType();
|
|
|
|
if P.tok == Scanner.ASSIGN {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpressionList();
|
|
|
|
}
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseVarDecl() {
|
|
|
|
P.Trace("VarDecl");
|
|
|
|
P.Expect(Scanner.VAR);
|
|
|
|
if P.tok == Scanner.LPAREN {
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
|
|
|
for P.tok != Scanner.RPAREN {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseVarSpec();
|
2008-07-08 19:37:31 -06:00
|
|
|
if P.tok != Scanner.RPAREN {
|
|
|
|
P.Expect(Scanner.SEMICOLON);
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
} else {
|
|
|
|
P.ParseVarSpec();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseParameterSection() {
|
|
|
|
P.Trace("ParameterSection");
|
|
|
|
P.ParseIdentList();
|
|
|
|
P.ParseType();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseParameterList() {
|
|
|
|
P.Trace("ParameterList");
|
|
|
|
P.ParseParameterSection();
|
|
|
|
for P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParseParameterSection();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseParameters() {
|
|
|
|
P.Trace("Parameters");
|
|
|
|
P.Expect(Scanner.LPAREN);
|
|
|
|
if P.tok != Scanner.RPAREN {
|
|
|
|
P.ParseParameterList();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RPAREN);
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseResult() {
|
|
|
|
P.Trace("Result");
|
|
|
|
if P.tok == Scanner.LPAREN {
|
|
|
|
// TODO: here we allow empty returns - should proably fix this
|
|
|
|
P.ParseParameters();
|
|
|
|
} else {
|
|
|
|
P.ParseType();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Named signatures
|
|
|
|
//
|
|
|
|
// name (params)
|
|
|
|
// name (params) type
|
|
|
|
// name (params) (results)
|
|
|
|
// (recv) name (params)
|
|
|
|
// (recv) name (params) type
|
|
|
|
// (recv) name (params) (results)
|
|
|
|
|
|
|
|
func (P *Parser) ParseNamedSignature() {
|
|
|
|
P.Trace("NamedSignature");
|
|
|
|
if P.tok == Scanner.LPAREN {
|
|
|
|
P.ParseParameters();
|
|
|
|
}
|
|
|
|
|
|
|
|
P.ParseIdent(); // function name
|
|
|
|
|
|
|
|
P.ParseParameters();
|
|
|
|
|
|
|
|
// TODO factor this code
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.IDENT, Scanner.LBRACK, Scanner.CHAN, Scanner.INTERFACE,
|
|
|
|
Scanner.FUNC, Scanner.MAP, Scanner.STRUCT, Scanner.MUL, Scanner.LPAREN:
|
|
|
|
P.ParseResult();
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseDeclaration();
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) TryStatement() bool;
|
2008-07-08 17:39:04 -06:00
|
|
|
func (P *Parser) ParseStatementList();
|
2008-07-07 18:27:14 -06:00
|
|
|
func (P *Parser) ParseBlock();
|
2008-07-08 17:39:04 -06:00
|
|
|
func (P *Parser) ParsePrimaryExpr();
|
2008-07-07 18:27:14 -06:00
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParsePrimaryExprList() {
|
|
|
|
P.Trace("PrimaryExprList");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.ParsePrimaryExpr();
|
|
|
|
for P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParsePrimaryExpr();
|
|
|
|
}
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseBuiltinStat() {
|
|
|
|
P.Trace("BuiltinStat");
|
|
|
|
P.Expect(Scanner.IDENT);
|
|
|
|
P.ParseExpressionList(); // TODO should be optional
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseSimpleStat() {
|
|
|
|
P.Trace("SimpleStat");
|
|
|
|
P.ParseExpression();
|
2008-07-08 19:37:31 -06:00
|
|
|
if P.tok == Scanner.COLON {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Next();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Ecart();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if P.tok == Scanner.COMMA {
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Next();
|
|
|
|
P.ParsePrimaryExprList();
|
2008-07-08 19:37:31 -06:00
|
|
|
}
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.ASSIGN: fallthrough;
|
|
|
|
case Scanner.DEFINE: fallthrough;
|
|
|
|
case Scanner.ADD_ASSIGN: fallthrough;
|
|
|
|
case Scanner.SUB_ASSIGN: fallthrough;
|
|
|
|
case Scanner.MUL_ASSIGN: fallthrough;
|
|
|
|
case Scanner.QUO_ASSIGN: fallthrough;
|
|
|
|
case Scanner.REM_ASSIGN: fallthrough;
|
|
|
|
case Scanner.AND_ASSIGN: fallthrough;
|
|
|
|
case Scanner.OR_ASSIGN: fallthrough;
|
|
|
|
case Scanner.XOR_ASSIGN: fallthrough;
|
|
|
|
case Scanner.SHL_ASSIGN: fallthrough;
|
|
|
|
case Scanner.SHR_ASSIGN:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Next();
|
|
|
|
P.ParseExpressionList();
|
2008-07-07 18:27:14 -06:00
|
|
|
case Scanner.INC:
|
|
|
|
P.Next();
|
|
|
|
case Scanner.DEC:
|
|
|
|
P.Next();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) ParseGoStat() {
|
|
|
|
P.Trace("GoStat");
|
|
|
|
P.Expect(Scanner.GO);
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 17:39:04 -06:00
|
|
|
func (P *Parser) ParseReturnStat() {
|
|
|
|
P.Trace("ReturnStat");
|
|
|
|
P.Expect(Scanner.RETURN);
|
|
|
|
if P.tok != Scanner.SEMICOLON && P.tok != Scanner.RBRACE {
|
|
|
|
P.ParseExpressionList();
|
|
|
|
}
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) ParseControlFlowStat(tok int) {
|
|
|
|
P.Trace("ControlFlowStat");
|
|
|
|
P.Expect(tok);
|
2008-07-08 17:39:04 -06:00
|
|
|
if P.tok == Scanner.IDENT {
|
|
|
|
P.ParseIdent();
|
|
|
|
}
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) ParseStatement() {
|
|
|
|
P.Trace("Statement");
|
|
|
|
if !P.TryStatement() {
|
|
|
|
P.Error("statement expected");
|
2008-07-08 17:39:04 -06:00
|
|
|
}
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseIfStat() {
|
|
|
|
P.Trace("IfStat");
|
|
|
|
P.Expect(Scanner.IF);
|
|
|
|
if P.tok != Scanner.LBRACE {
|
|
|
|
P.ParseSimpleStat();
|
|
|
|
if P.tok == Scanner.SEMICOLON {
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
P.ParseBlock();
|
|
|
|
if P.tok == Scanner.ELSE {
|
|
|
|
P.Next();
|
|
|
|
if P.tok == Scanner.IF {
|
|
|
|
P.ParseIfStat();
|
|
|
|
} else {
|
|
|
|
// TODO should be P.ParseBlock()
|
2008-07-08 19:37:31 -06:00
|
|
|
P.ParseStatement();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseForStat() {
|
|
|
|
P.Trace("ForStat");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.FOR);
|
|
|
|
if P.tok != Scanner.LBRACE {
|
|
|
|
if P.tok != Scanner.SEMICOLON {
|
|
|
|
P.ParseSimpleStat();
|
|
|
|
}
|
|
|
|
if P.tok == Scanner.SEMICOLON {
|
|
|
|
P.Next();
|
|
|
|
if P.tok != Scanner.SEMICOLON {
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.SEMICOLON);
|
|
|
|
if P.tok != Scanner.LBRACE {
|
|
|
|
P.ParseSimpleStat();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
P.ParseBlock();
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseCase() {
|
|
|
|
P.Trace("Case");
|
|
|
|
if P.tok == Scanner.CASE {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpressionList();
|
|
|
|
} else {
|
|
|
|
P.Expect(Scanner.DEFAULT);
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.COLON);
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseCaseList() {
|
|
|
|
P.Trace("CaseList");
|
|
|
|
P.ParseCase();
|
|
|
|
for P.tok == Scanner.CASE || P.tok == Scanner.DEFAULT {
|
|
|
|
P.ParseCase();
|
|
|
|
}
|
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseCaseClause() {
|
|
|
|
P.Trace("CaseClause");
|
|
|
|
P.ParseCaseList();
|
|
|
|
if P.tok != Scanner.FALLTHROUGH && P.tok != Scanner.RBRACE {
|
|
|
|
P.ParseStatementList();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-08 17:39:04 -06:00
|
|
|
}
|
|
|
|
if P.tok == Scanner.FALLTHROUGH {
|
|
|
|
P.Next();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-08 17:39:04 -06:00
|
|
|
}
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseSwitchStat() {
|
|
|
|
P.Trace("SwitchStat");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.SWITCH);
|
|
|
|
if P.tok != Scanner.LBRACE {
|
|
|
|
P.ParseSimpleStat();
|
|
|
|
if P.tok == Scanner.SEMICOLON {
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.LBRACE);
|
|
|
|
for P.tok != Scanner.RBRACE {
|
|
|
|
P.ParseCaseClause();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RBRACE);
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-08 19:37:31 -06:00
|
|
|
func (P *Parser) TryStatement() bool {
|
|
|
|
P.Trace("Statement (try)");
|
2008-07-07 18:27:14 -06:00
|
|
|
switch P.tok {
|
|
|
|
case Scanner.CONST: fallthrough;
|
|
|
|
case Scanner.TYPE: fallthrough;
|
|
|
|
case Scanner.VAR: fallthrough;
|
|
|
|
case Scanner.FUNC:
|
|
|
|
P.ParseDeclaration();
|
2008-07-08 19:37:31 -06:00
|
|
|
case Scanner.GTR:
|
|
|
|
P.ParseSimpleStat(); // send
|
2008-07-07 18:27:14 -06:00
|
|
|
case Scanner.IDENT:
|
2008-07-08 17:39:04 -06:00
|
|
|
switch P.ident {
|
|
|
|
case "print", "panic":
|
|
|
|
P.ParseBuiltinStat();
|
|
|
|
default:
|
|
|
|
P.ParseSimpleStat();
|
|
|
|
}
|
2008-07-07 18:27:14 -06:00
|
|
|
case Scanner.GO:
|
2008-07-08 19:37:31 -06:00
|
|
|
P.ParseGoStat();
|
2008-07-07 18:27:14 -06:00
|
|
|
case Scanner.RETURN:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.ParseReturnStat();
|
2008-07-08 19:37:31 -06:00
|
|
|
case Scanner.BREAK, Scanner.CONTINUE, Scanner.GOTO:
|
|
|
|
P.ParseControlFlowStat(P.tok);
|
2008-07-07 18:27:14 -06:00
|
|
|
case Scanner.LBRACE:
|
|
|
|
P.ParseBlock();
|
|
|
|
case Scanner.IF:
|
|
|
|
P.ParseIfStat();
|
|
|
|
case Scanner.FOR:
|
|
|
|
P.ParseForStat();
|
|
|
|
case Scanner.SWITCH:
|
|
|
|
P.ParseSwitchStat();
|
|
|
|
case Scanner.RANGE:
|
|
|
|
panic "range statement";
|
|
|
|
case Scanner.SELECT:
|
|
|
|
panic "select statement";
|
|
|
|
default:
|
2008-07-08 17:39:04 -06:00
|
|
|
// no statement found
|
|
|
|
P.Ecart();
|
|
|
|
return false;
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
|
|
|
return true;
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseStatementList() {
|
|
|
|
P.Trace("StatementList");
|
2008-07-08 19:37:31 -06:00
|
|
|
for P.TryStatement() {
|
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseBlock() {
|
|
|
|
P.Trace("Block");
|
|
|
|
P.Expect(Scanner.LBRACE);
|
|
|
|
if P.tok != Scanner.RBRACE && P.tok != Scanner.SEMICOLON {
|
|
|
|
P.ParseStatementList();
|
|
|
|
}
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
P.Expect(Scanner.RBRACE);
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseFuncDecl() {
|
|
|
|
P.Trace("FuncDecl");
|
|
|
|
P.Expect(Scanner.FUNC);
|
|
|
|
P.ParseNamedSignature();
|
|
|
|
if P.tok == Scanner.SEMICOLON {
|
|
|
|
// forward declaration
|
|
|
|
P.Next();
|
|
|
|
} else {
|
|
|
|
P.ParseBlock();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseExportDecl() {
|
|
|
|
P.Trace("ExportDecl");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.EXPORT);
|
2008-07-09 11:16:33 -06:00
|
|
|
if P.tok == Scanner.LPAREN {
|
|
|
|
P.Next();
|
|
|
|
for P.tok != Scanner.RPAREN {
|
|
|
|
P.ParseIdent();
|
|
|
|
P.Optional(Scanner.COMMA); // TODO this seems wrong
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Next();
|
2008-07-09 11:16:33 -06:00
|
|
|
} else {
|
2008-07-08 17:39:04 -06:00
|
|
|
P.ParseIdent();
|
2008-07-09 11:16:33 -06:00
|
|
|
for P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParseIdent();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
}
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseDeclaration() {
|
|
|
|
P.Trace("Declaration");
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.CONST:
|
|
|
|
P.ParseConstDecl();
|
|
|
|
case Scanner.TYPE:
|
|
|
|
P.ParseTypeDecl();
|
|
|
|
case Scanner.VAR:
|
|
|
|
P.ParseVarDecl();
|
|
|
|
case Scanner.FUNC:
|
|
|
|
P.ParseFuncDecl();
|
|
|
|
case Scanner.EXPORT:
|
|
|
|
P.ParseExportDecl();
|
|
|
|
default:
|
|
|
|
P.Error("declaration expected");
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseNew() {
|
|
|
|
P.Trace("New");
|
|
|
|
P.Expect(Scanner.NEW);
|
|
|
|
P.Expect(Scanner.LPAREN);
|
|
|
|
P.ParseType();
|
|
|
|
if P.tok == Scanner.COMMA {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpressionList()
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RPAREN);
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseOperand() {
|
|
|
|
P.Trace("Operand");
|
2008-07-08 17:39:04 -06:00
|
|
|
switch P.tok {
|
|
|
|
case Scanner.IDENT:
|
|
|
|
P.ParseQualifiedIdent();
|
|
|
|
case Scanner.LPAREN:
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpression();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Expect(Scanner.RPAREN);
|
2008-07-09 11:16:33 -06:00
|
|
|
case Scanner.STRING: fallthrough;
|
|
|
|
case Scanner.NUMBER: fallthrough;
|
2008-07-08 19:37:31 -06:00
|
|
|
case Scanner.NIL: fallthrough;
|
2008-07-08 17:39:04 -06:00
|
|
|
case Scanner.IOTA: fallthrough;
|
|
|
|
case Scanner.TRUE: fallthrough;
|
|
|
|
case Scanner.FALSE:
|
|
|
|
P.Next();
|
|
|
|
case Scanner.NEW:
|
|
|
|
P.ParseNew();
|
|
|
|
default:
|
|
|
|
panic "unknown operand"
|
|
|
|
}
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseSelectorOrTypeAssertion() {
|
|
|
|
P.Trace("SelectorOrTypeAssertion");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.PERIOD);
|
|
|
|
if P.tok == Scanner.IDENT {
|
|
|
|
P.ParseIdent();
|
|
|
|
} else {
|
|
|
|
P.Expect(Scanner.LPAREN);
|
|
|
|
P.ParseType();
|
|
|
|
P.Expect(Scanner.RPAREN);
|
|
|
|
}
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseIndexOrSlice() {
|
|
|
|
P.Trace("IndexOrSlice");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.LBRACK);
|
|
|
|
P.ParseExpression();
|
|
|
|
if P.tok == Scanner.COLON {
|
|
|
|
P.Next();
|
|
|
|
P.ParseExpression();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RBRACK);
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseInvocation() {
|
|
|
|
P.Trace("Invocation");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Expect(Scanner.LPAREN);
|
|
|
|
if P.tok != Scanner.RPAREN {
|
|
|
|
P.ParseExpressionList();
|
|
|
|
}
|
|
|
|
P.Expect(Scanner.RPAREN);
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParsePrimaryExpr() {
|
|
|
|
P.Trace("PrimaryExpr");
|
|
|
|
P.ParseOperand();
|
|
|
|
for {
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.PERIOD:
|
|
|
|
P.ParseSelectorOrTypeAssertion();
|
|
|
|
case Scanner.LBRACK:
|
|
|
|
P.ParseIndexOrSlice();
|
|
|
|
case Scanner.LPAREN:
|
|
|
|
P.ParseInvocation();
|
|
|
|
default:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseUnaryExpr() {
|
|
|
|
P.Trace("UnaryExpr");
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.ADD: fallthrough;
|
|
|
|
case Scanner.SUB: fallthrough;
|
|
|
|
case Scanner.NOT: fallthrough;
|
|
|
|
case Scanner.XOR: fallthrough;
|
|
|
|
case Scanner.LSS: fallthrough;
|
|
|
|
case Scanner.GTR: fallthrough;
|
|
|
|
case Scanner.MUL: fallthrough;
|
|
|
|
case Scanner.AND:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseUnaryExpr();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
P.ParsePrimaryExpr();
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseMultiplicativeExpr() {
|
|
|
|
P.Trace("MultiplicativeExpr");
|
|
|
|
P.ParseUnaryExpr();
|
|
|
|
for {
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.MUL: fallthrough;
|
|
|
|
case Scanner.QUO: fallthrough;
|
|
|
|
case Scanner.REM: fallthrough;
|
|
|
|
case Scanner.SHL: fallthrough;
|
|
|
|
case Scanner.SHR: fallthrough;
|
|
|
|
case Scanner.AND:
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseUnaryExpr();
|
|
|
|
default:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseAdditiveExpr() {
|
|
|
|
P.Trace("AdditiveExpr");
|
|
|
|
P.ParseMultiplicativeExpr();
|
|
|
|
for {
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.ADD: fallthrough;
|
|
|
|
case Scanner.SUB: fallthrough;
|
|
|
|
case Scanner.OR: fallthrough;
|
|
|
|
case Scanner.XOR:
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseMultiplicativeExpr();
|
|
|
|
default:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseRelationalExpr() {
|
|
|
|
P.Trace("RelationalExpr");
|
|
|
|
P.ParseAdditiveExpr();
|
|
|
|
switch P.tok {
|
|
|
|
case Scanner.EQL: fallthrough;
|
|
|
|
case Scanner.NEQ: fallthrough;
|
|
|
|
case Scanner.LSS: fallthrough;
|
|
|
|
case Scanner.LEQ: fallthrough;
|
|
|
|
case Scanner.GTR: fallthrough;
|
|
|
|
case Scanner.GEQ:
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Next();
|
2008-07-07 18:27:14 -06:00
|
|
|
P.ParseAdditiveExpr();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseLANDExpr() {
|
|
|
|
P.Trace("LANDExpr");
|
|
|
|
P.ParseRelationalExpr();
|
|
|
|
for P.tok == Scanner.CAND {
|
|
|
|
P.Next();
|
|
|
|
P.ParseRelationalExpr();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseLORExpr() {
|
|
|
|
P.Trace("LORExpr");
|
|
|
|
P.ParseLANDExpr();
|
|
|
|
for P.tok == Scanner.COR {
|
|
|
|
P.Next();
|
|
|
|
P.ParseLANDExpr();
|
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseExpression() {
|
|
|
|
P.Trace("Expression");
|
2008-07-08 17:39:04 -06:00
|
|
|
P.ParseLORExpr();
|
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
func (P *Parser) ParseProgram() {
|
|
|
|
P.Trace("Program");
|
|
|
|
P.Expect(Scanner.PACKAGE);
|
|
|
|
P.ParseIdent();
|
|
|
|
for P.tok == Scanner.IMPORT {
|
|
|
|
P.ParseImportDecl();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
|
|
|
for P.tok != Scanner.EOF {
|
|
|
|
P.ParseDeclaration();
|
2008-07-08 19:37:31 -06:00
|
|
|
P.Optional(Scanner.SEMICOLON);
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|
2008-07-08 17:39:04 -06:00
|
|
|
P.Ecart();
|
2008-07-07 18:27:14 -06:00
|
|
|
}
|