Skip to content

G
go
Commit 0cee3028 authored by Robert Griesemer's avatar Robert Griesemer
Browse files
Options

- func reorg to reduce forward decls and improve structure 

SVN=127229
parent d9d5f3b3
Hide whitespace changes
Inline Side-by-side
Showing with 372 additions and 364 deletions
usr/gri/gosrc/parser.go
View file @ 0cee3028
...@@ -127,9 +127,13 @@ func (P *Parser) Declare(obj *Globals.Object) { ...@@ -127,9 +127,13 @@ func (P *Parser) Declare(obj *Globals.Object) {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Common productions
func (P *Parser) TryType() bool; func (P *Parser) TryType() bool;
func (P *Parser) ParseExpression(); func (P *Parser) ParseExpression();
func (P *Parser) TryStatement() bool;
func (P *Parser) ParseDeclaration();
func (P *Parser) ParseIdent() { func (P *Parser) ParseIdent() {
...@@ -163,12 +167,8 @@ func (P *Parser) ParseQualifiedIdent() { ...@@ -163,12 +167,8 @@ func (P *Parser) ParseQualifiedIdent() {
} }
func (P *Parser) ParseTypeName() { // ----------------------------------------------------------------------------
P.Trace("TypeName"); // Types
P.ParseQualifiedIdent();
P.Ecart();
}
func (P *Parser) ParseType() { func (P *Parser) ParseType() {
P.Trace("Type"); P.Trace("Type");
...@@ -179,6 +179,13 @@ func (P *Parser) ParseType() { ...@@ -179,6 +179,13 @@ func (P *Parser) ParseType() {
} }
func (P *Parser) ParseTypeName() {
P.Trace("TypeName");
P.ParseQualifiedIdent();
P.Ecart();
}
func (P *Parser) ParseArrayType() { func (P *Parser) ParseArrayType() {
P.Trace("ArrayType"); P.Trace("ArrayType");
P.Expect(Scanner.LBRACK); P.Expect(Scanner.LBRACK);
...@@ -204,8 +211,103 @@ func (P *Parser) ParseChannelType() { ...@@ -204,8 +211,103 @@ func (P *Parser) ParseChannelType() {
} }
func (P *Parser) ParseParameters(); func (P *Parser) ParseParameterSection() {
func (P *Parser) TryResult() bool; P.Trace("ParameterSection");
P.ParseIdentList();
P.ParseType();
P.Ecart();
}
func (P *Parser) ParseParameterList() {
P.Trace("ParameterList");
P.ParseParameterSection();
for P.tok == Scanner.COMMA {
P.Next();
P.ParseParameterSection();
}
P.Ecart();
}
func (P *Parser) ParseParameters() {
P.Trace("Parameters");
P.Expect(Scanner.LPAREN);
if P.tok != Scanner.RPAREN {
P.ParseParameterList();
}
P.Expect(Scanner.RPAREN);
P.Ecart();
}
func (P *Parser) TryResult() bool {
P.Trace("Result (try)");
res := false;
if P.tok == Scanner.LPAREN {
// TODO: here we allow empty returns - should proably fix this
P.ParseParameters();
res = true;
} else {
res = P.TryType();
}
P.Ecart();
return res;
}
// Anonymous signatures
//
// (params)
// (params) type
// (params) (results)
// (recv) . (params)
// (recv) . (params) type
// (recv) . (params) (results)
func (P *Parser) ParseAnonymousSignature() {
P.Trace("AnonymousSignature");
P.OpenScope();
P.ParseParameters();
if P.tok == Scanner.PERIOD {
P.Next();
P.ParseParameters();
}
P.TryResult();
P.CloseScope();
P.Ecart();
}
// 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");
P.OpenScope();
if P.tok == Scanner.LPAREN {
P.ParseParameters();
}
P.ParseIdent(); // function name
P.ParseParameters();
P.TryResult();
P.CloseScope();
P.Ecart();
}
func (P *Parser) ParseFunctionType() {
P.Trace("FunctionType");
P.Expect(Scanner.FUNC);
P.ParseAnonymousSignature();
P.Ecart();
}
func (P *Parser) ParseMethodDecl() { func (P *Parser) ParseMethodDecl() {
...@@ -232,17 +334,6 @@ func (P *Parser) ParseInterfaceType() { ...@@ -232,17 +334,6 @@ func (P *Parser) ParseInterfaceType() {
} }
func (P *Parser) ParseAnonymousSignature();
func (P *Parser) ParseFunctionType() {
P.Trace("FunctionType");
P.Expect(Scanner.FUNC);
P.ParseAnonymousSignature();
P.Ecart();
}
func (P *Parser) ParseMapType() { func (P *Parser) ParseMapType() {
P.Trace("MapType"); P.Trace("MapType");
P.Expect(Scanner.MAP); P.Expect(Scanner.MAP);
...@@ -316,51 +407,48 @@ func (P *Parser) TryType() bool { ...@@ -316,51 +407,48 @@ func (P *Parser) TryType() bool {
} }
func (P *Parser) ParseImportSpec() { // ----------------------------------------------------------------------------
P.Trace("ImportSpec"); // Blocks
if P.tok == Scanner.PERIOD {
P.Next(); func (P *Parser) ParseStatement() {
} else if P.tok == Scanner.IDENT { P.Trace("Statement");
P.Next(); if !P.TryStatement() {
P.Error(P.beg, "statement expected");
} }
P.Expect(Scanner.STRING);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseImportDecl() { func (P *Parser) ParseStatementList() {
P.Trace("ImportDecl"); P.Trace("StatementList");
P.Expect(Scanner.IMPORT); for P.TryStatement() {
if P.tok == Scanner.LPAREN { P.Optional(Scanner.SEMICOLON);
P.Next();
for P.tok != Scanner.RPAREN {
P.ParseImportSpec();
P.Optional(Scanner.SEMICOLON); // TODO this seems wrong
}
P.Next();
} else {
P.ParseImportSpec();
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseExpressionList() { func (P *Parser) ParseBlock() {
P.Trace("ExpressionList"); P.Trace("Block");
P.ParseExpression(); P.Expect(Scanner.LBRACE);
for P.tok == Scanner.COMMA { P.OpenScope();
P.Next(); if P.tok != Scanner.RBRACE && P.tok != Scanner.SEMICOLON {
P.ParseExpression(); P.ParseStatementList();
} }
P.Optional(Scanner.SEMICOLON);
P.CloseScope();
P.Expect(Scanner.RBRACE);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseConstSpec() { // ----------------------------------------------------------------------------
P.Trace("ConstSpec"); // Expressions
P.ParseIdent();
P.TryType(); func (P *Parser) ParseExpressionList() {
if P.tok == Scanner.ASSIGN { P.Trace("ExpressionList");
P.ParseExpression();
for P.tok == Scanner.COMMA {
P.Next(); P.Next();
P.ParseExpression(); P.ParseExpression();
} }
...@@ -368,197 +456,190 @@ func (P *Parser) ParseConstSpec() { ...@@ -368,197 +456,190 @@ func (P *Parser) ParseConstSpec() {
} }
func (P *Parser) ParseConstDecl() { func (P *Parser) ParseNew() {
P.Trace("ConstDecl"); P.Trace("New");
P.Expect(Scanner.CONST); P.Expect(Scanner.NEW);
if P.tok == Scanner.LPAREN { P.Expect(Scanner.LPAREN);
P.Next(); P.ParseType();
for P.tok != Scanner.RPAREN { if P.tok == Scanner.COMMA {
P.ParseConstSpec();
if P.tok != Scanner.RPAREN {
P.Expect(Scanner.SEMICOLON);
}
}
P.Next(); P.Next();
} else { P.ParseExpressionList()
P.ParseConstSpec();
} }
P.Expect(Scanner.RPAREN);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseTypeSpec() { func (P *Parser) ParseFunctionLit() {
P.Trace("TypeSpec"); P.Trace("FunctionLit");
P.ParseIdent(); P.ParseFunctionType();
P.TryType(); P.ParseBlock();
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseTypeDecl() { func (P *Parser) ParseOperand() {
P.Trace("TypeDecl"); P.Trace("Operand");
P.Expect(Scanner.TYPE); switch P.tok {
if P.tok == Scanner.LPAREN { case Scanner.IDENT:
P.ParseQualifiedIdent();
case Scanner.LPAREN:
P.Next(); P.Next();
for P.tok != Scanner.RPAREN { P.ParseExpression();
P.ParseTypeSpec(); P.Expect(Scanner.RPAREN);
if P.tok != Scanner.RPAREN { case Scanner.STRING: fallthrough;
P.Expect(Scanner.SEMICOLON); case Scanner.NUMBER: fallthrough;
} case Scanner.NIL: fallthrough;
} case Scanner.IOTA: fallthrough;
case Scanner.TRUE: fallthrough;
case Scanner.FALSE:
P.Next(); P.Next();
} else { case Scanner.FUNC:
P.ParseTypeSpec(); P.ParseFunctionLit();
case Scanner.NEW:
P.ParseNew();
default:
P.Error(P.beg, "operand expected");
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseVarSpec() { func (P *Parser) ParseSelectorOrTypeAssertion() {
P.Trace("VarSpec"); P.Trace("SelectorOrTypeAssertion");
P.ParseIdentList(); P.Expect(Scanner.PERIOD);
if P.tok == Scanner.ASSIGN { if P.tok == Scanner.IDENT {
P.Next(); P.ParseIdent();
P.ParseExpressionList();
} else { } else {
P.Expect(Scanner.LPAREN);
P.ParseType(); P.ParseType();
if P.tok == Scanner.ASSIGN { P.Expect(Scanner.RPAREN);
P.Next();
P.ParseExpressionList();
}
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseVarDecl() { func (P *Parser) ParseIndexOrSlice() {
P.Trace("VarDecl"); P.Trace("IndexOrSlice");
P.Expect(Scanner.VAR); P.Expect(Scanner.LBRACK);
if P.tok == Scanner.LPAREN { P.ParseExpression();
P.Next(); if P.tok == Scanner.COLON {
for P.tok != Scanner.RPAREN {
P.ParseVarSpec();
if P.tok != Scanner.RPAREN {
P.Expect(Scanner.SEMICOLON);
}
}
P.Next(); P.Next();
} else { P.ParseExpression();
P.ParseVarSpec();
} }
P.Expect(Scanner.RBRACK);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseParameterSection() { func (P *Parser) ParseInvocation() {
P.Trace("ParameterSection"); P.Trace("Invocation");
P.ParseIdentList(); P.Expect(Scanner.LPAREN);
P.ParseType(); if P.tok != Scanner.RPAREN {
P.ParseExpressionList();
}
P.Expect(Scanner.RPAREN);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseParameterList() { func (P *Parser) ParsePrimaryExpr() {
P.Trace("ParameterList"); P.Trace("PrimaryExpr");
P.ParseParameterSection(); P.ParseOperand();
for P.tok == Scanner.COMMA { for {
P.Next(); switch P.tok {
P.ParseParameterSection(); case Scanner.PERIOD:
P.ParseSelectorOrTypeAssertion();
case Scanner.LBRACK:
P.ParseIndexOrSlice();
case Scanner.LPAREN:
P.ParseInvocation();
default:
P.Ecart();
return;
}
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseParameters() { func (P *Parser) ParsePrimaryExprList() {
P.Trace("Parameters"); P.Trace("PrimaryExprList");
P.Expect(Scanner.LPAREN); P.ParsePrimaryExpr();
if P.tok != Scanner.RPAREN { for P.tok == Scanner.COMMA {
P.ParseParameterList(); P.Next();
P.ParsePrimaryExpr();
} }
P.Expect(Scanner.RPAREN);
P.Ecart(); P.Ecart();
} }
func (P *Parser) TryResult() bool { func (P *Parser) ParseUnaryExpr() {
P.Trace("Result (try)"); P.Trace("UnaryExpr");
res := false; switch P.tok {
if P.tok == Scanner.LPAREN { case Scanner.ADD: fallthrough;
// TODO: here we allow empty returns - should proably fix this case Scanner.SUB: fallthrough;
P.ParseParameters(); case Scanner.NOT: fallthrough;
res = true; case Scanner.XOR: fallthrough;
} else { case Scanner.LSS: fallthrough;
res = P.TryType(); case Scanner.GTR: fallthrough;
case Scanner.MUL: fallthrough;
case Scanner.AND:
P.Next();
P.ParseUnaryExpr();
P.Ecart();
return;
} }
P.ParsePrimaryExpr();
P.Ecart(); P.Ecart();
return res;
} }
// Anonymous signatures func Precedence(tok int) int {
// // TODO should use a map or array here for lookup
// (params) switch tok {
// (params) type case Scanner.LOR:
// (params) (results) return 1;
// (recv) . (params) case Scanner.LAND:
// (recv) . (params) type return 2;
// (recv) . (params) (results) case Scanner.EQL, Scanner.NEQ, Scanner.LSS, Scanner.LEQ, Scanner.GTR, Scanner.GEQ:
return 3;
func (P *Parser) ParseAnonymousSignature() { case Scanner.ADD, Scanner.SUB, Scanner.OR, Scanner.XOR:
P.Trace("AnonymousSignature"); return 4;
P.OpenScope(); case Scanner.MUL, Scanner.QUO, Scanner.REM, Scanner.SHL, Scanner.SHR, Scanner.AND:
P.ParseParameters(); return 5;
if P.tok == Scanner.PERIOD {
P.Next();
P.ParseParameters();
} }
P.TryResult(); return 0;
P.CloseScope();
P.Ecart();
} }
// Named signatures func (P *Parser) ParseBinaryExpr(prec1 int) {
// P.Trace("BinaryExpr");
// name (params) P.ParseUnaryExpr();
// name (params) type for prec := Precedence(P.tok); prec >= prec1; prec-- {
// name (params) (results) for Precedence(P.tok) == prec {
// (recv) name (params) P.Next();
// (recv) name (params) type P.ParseBinaryExpr(prec + 1);
// (recv) name (params) (results) }
func (P *Parser) ParseNamedSignature() {
P.Trace("NamedSignature");
P.OpenScope();
if P.tok == Scanner.LPAREN {
P.ParseParameters();
} }
P.ParseIdent(); // function name
P.ParseParameters();
P.TryResult();
P.CloseScope();
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseDeclaration(); func (P *Parser) ParseExpression() {
func (P *Parser) TryStatement() bool; P.Trace("Expression");
func (P *Parser) ParseStatementList(); indent := P.indent;
func (P *Parser) ParseBlock(); P.ParseBinaryExpr(1);
func (P *Parser) ParsePrimaryExpr(); if indent != P.indent {
panic "imbalanced tracing code";
func (P *Parser) ParsePrimaryExprList() {
P.Trace("PrimaryExprList");
P.ParsePrimaryExpr();
for P.tok == Scanner.COMMA {
P.Next();
P.ParsePrimaryExpr();
} }
P.Ecart(); P.Ecart();
} }
// ----------------------------------------------------------------------------
// Statements
func (P *Parser) ParseBuiltinStat() { func (P *Parser) ParseBuiltinStat() {
P.Trace("BuiltinStat"); P.Trace("BuiltinStat");
P.Expect(Scanner.IDENT); P.Expect(Scanner.IDENT);
...@@ -631,15 +712,6 @@ func (P *Parser) ParseControlFlowStat(tok int) { ...@@ -631,15 +712,6 @@ func (P *Parser) ParseControlFlowStat(tok int) {
} }
func (P *Parser) ParseStatement() {
P.Trace("Statement");
if !P.TryStatement() {
P.Error(P.beg, "statement expected");
}
P.Ecart();
}
func (P *Parser) ParseIfStat() { func (P *Parser) ParseIfStat() {
P.Trace("IfStat"); P.Trace("IfStat");
P.Expect(Scanner.IF); P.Expect(Scanner.IF);
...@@ -870,258 +942,194 @@ func (P *Parser) TryStatement() bool { ...@@ -870,258 +942,194 @@ func (P *Parser) TryStatement() bool {
} }
func (P *Parser) ParseStatementList() { // ----------------------------------------------------------------------------
P.Trace("StatementList"); // Declarations
for P.TryStatement() {
P.Optional(Scanner.SEMICOLON);
}
P.Ecart();
}
func (P *Parser) ParseBlock() {
P.Trace("Block");
P.Expect(Scanner.LBRACE);
P.OpenScope();
if P.tok != Scanner.RBRACE && P.tok != Scanner.SEMICOLON {
P.ParseStatementList();
}
P.Optional(Scanner.SEMICOLON);
P.CloseScope();
P.Expect(Scanner.RBRACE);
P.Ecart();
}
func (P *Parser) ParseFuncDecl() { func (P *Parser) ParseImportSpec() {
P.Trace("FuncDecl"); P.Trace("ImportSpec");
P.Expect(Scanner.FUNC); if P.tok == Scanner.PERIOD {
P.ParseNamedSignature(); P.Next();
if P.tok == Scanner.SEMICOLON { } else if P.tok == Scanner.IDENT {
// forward declaration
P.Next(); P.Next();
} else {
P.ParseBlock();
} }
P.Expect(Scanner.STRING);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseExportDecl() { func (P *Parser) ParseImportDecl() {
P.Trace("ExportDecl"); P.Trace("ImportDecl");
P.Expect(Scanner.EXPORT); P.Expect(Scanner.IMPORT);
if P.tok == Scanner.LPAREN { if P.tok == Scanner.LPAREN {
P.Next(); P.Next();
for P.tok != Scanner.RPAREN { for P.tok != Scanner.RPAREN {
P.ParseIdent(); P.ParseImportSpec();
P.Optional(Scanner.COMMA); // TODO this seems wrong P.Optional(Scanner.SEMICOLON); // TODO this seems wrong
} }
P.Next(); P.Next();
} else { } else {
P.ParseIdent(); P.ParseImportSpec();
for P.tok == Scanner.COMMA {
P.Next();
P.ParseIdent();
}
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseDeclaration() { func (P *Parser) ParseConstSpec() {
P.Trace("Declaration"); P.Trace("ConstSpec");
indent := P.indent; P.ParseIdent();
switch P.tok { P.TryType();
case Scanner.CONST: if P.tok == Scanner.ASSIGN {
P.ParseConstDecl(); P.Next();
case Scanner.TYPE: P.ParseExpression();
P.ParseTypeDecl();
case Scanner.VAR:
P.ParseVarDecl();
case Scanner.FUNC:
P.ParseFuncDecl();
case Scanner.EXPORT:
P.ParseExportDecl();
default:
P.Error(P.beg, "declaration expected");
}
if indent != P.indent {
panic "imbalanced tracing code"
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseNew() { func (P *Parser) ParseConstDecl() {
P.Trace("New"); P.Trace("ConstDecl");
P.Expect(Scanner.NEW); P.Expect(Scanner.CONST);
P.Expect(Scanner.LPAREN); if P.tok == Scanner.LPAREN {
P.ParseType();
if P.tok == Scanner.COMMA {
P.Next(); P.Next();
P.ParseExpressionList() for P.tok != Scanner.RPAREN {
P.ParseConstSpec();
if P.tok != Scanner.RPAREN {
P.Expect(Scanner.SEMICOLON);
}
}
P.Next();
} else {
P.ParseConstSpec();
} }
P.Expect(Scanner.RPAREN);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseFunctionLit() { func (P *Parser) ParseTypeSpec() {
P.Trace("FunctionLit"); P.Trace("TypeSpec");
P.ParseFunctionType(); P.ParseIdent();
P.ParseBlock(); P.TryType();
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseOperand() { func (P *Parser) ParseTypeDecl() {
P.Trace("Operand"); P.Trace("TypeDecl");
switch P.tok { P.Expect(Scanner.TYPE);
case Scanner.IDENT: if P.tok == Scanner.LPAREN {
P.ParseQualifiedIdent();
case Scanner.LPAREN:
P.Next(); P.Next();
P.ParseExpression(); for P.tok != Scanner.RPAREN {
P.Expect(Scanner.RPAREN); P.ParseTypeSpec();
case Scanner.STRING: fallthrough; if P.tok != Scanner.RPAREN {
case Scanner.NUMBER: fallthrough; P.Expect(Scanner.SEMICOLON);
case Scanner.NIL: fallthrough; }
case Scanner.IOTA: fallthrough; }
case Scanner.TRUE: fallthrough;
case Scanner.FALSE:
P.Next(); P.Next();
case Scanner.FUNC:
P.ParseFunctionLit();
case Scanner.NEW:
P.ParseNew();
default:
P.Error(P.beg, "operand expected");
}
P.Ecart();
}
func (P *Parser) ParseSelectorOrTypeAssertion() {
P.Trace("SelectorOrTypeAssertion");
P.Expect(Scanner.PERIOD);
if P.tok == Scanner.IDENT {
P.ParseIdent();
} else { } else {
P.Expect(Scanner.LPAREN); P.ParseTypeSpec();
P.ParseType();
P.Expect(Scanner.RPAREN);
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseIndexOrSlice() { func (P *Parser) ParseVarSpec() {
P.Trace("IndexOrSlice"); P.Trace("VarSpec");
P.Expect(Scanner.LBRACK); P.ParseIdentList();
P.ParseExpression(); if P.tok == Scanner.ASSIGN {
if P.tok == Scanner.COLON {
P.Next(); P.Next();
P.ParseExpression();
}
P.Expect(Scanner.RBRACK);
P.Ecart();
}
func (P *Parser) ParseInvocation() {
P.Trace("Invocation");
P.Expect(Scanner.LPAREN);
if P.tok != Scanner.RPAREN {
P.ParseExpressionList(); P.ParseExpressionList();
} else {
P.ParseType();
if P.tok == Scanner.ASSIGN {
P.Next();
P.ParseExpressionList();
}
} }
P.Expect(Scanner.RPAREN);
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParsePrimaryExpr() { func (P *Parser) ParseVarDecl() {
P.Trace("PrimaryExpr"); P.Trace("VarDecl");
P.ParseOperand(); P.Expect(Scanner.VAR);
for { if P.tok == Scanner.LPAREN {
switch P.tok { P.Next();
case Scanner.PERIOD: for P.tok != Scanner.RPAREN {
P.ParseSelectorOrTypeAssertion(); P.ParseVarSpec();
case Scanner.LBRACK: if P.tok != Scanner.RPAREN {
P.ParseIndexOrSlice(); P.Expect(Scanner.SEMICOLON);
case Scanner.LPAREN: }
P.ParseInvocation();
default:
P.Ecart();
return;
} }
P.Next();
} else {
P.ParseVarSpec();
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseUnaryExpr() { func (P *Parser) ParseFuncDecl() {
P.Trace("UnaryExpr"); P.Trace("FuncDecl");
switch P.tok { P.Expect(Scanner.FUNC);
case Scanner.ADD: fallthrough; P.ParseNamedSignature();
case Scanner.SUB: fallthrough; if P.tok == Scanner.SEMICOLON {
case Scanner.NOT: fallthrough; // forward declaration
case Scanner.XOR: fallthrough;
case Scanner.LSS: fallthrough;
case Scanner.GTR: fallthrough;
case Scanner.MUL: fallthrough;
case Scanner.AND:
P.Next(); P.Next();
P.ParseUnaryExpr(); } else {
P.Ecart(); P.ParseBlock();
return;
} }
P.ParsePrimaryExpr();
P.Ecart(); P.Ecart();
} }
func Precedence(tok int) int { func (P *Parser) ParseExportDecl() {
// TODO should use a map or array here for lookup P.Trace("ExportDecl");
switch tok { P.Expect(Scanner.EXPORT);
case Scanner.LOR: if P.tok == Scanner.LPAREN {
return 1; P.Next();
case Scanner.LAND: for P.tok != Scanner.RPAREN {
return 2; P.ParseIdent();
case Scanner.EQL, Scanner.NEQ, Scanner.LSS, Scanner.LEQ, Scanner.GTR, Scanner.GEQ: P.Optional(Scanner.COMMA); // TODO this seems wrong
return 3; }
case Scanner.ADD, Scanner.SUB, Scanner.OR, Scanner.XOR: P.Next();
return 4; } else {
case Scanner.MUL, Scanner.QUO, Scanner.REM, Scanner.SHL, Scanner.SHR, Scanner.AND: P.ParseIdent();
return 5; for P.tok == Scanner.COMMA {
}
return 0;
}
func (P *Parser) ParseBinaryExpr(prec1 int) {
P.Trace("BinaryExpr");
P.ParseUnaryExpr();
for prec := Precedence(P.tok); prec >= prec1; prec-- {
for Precedence(P.tok) == prec {
P.Next(); P.Next();
P.ParseBinaryExpr(prec + 1); P.ParseIdent();
} }
} }
P.Ecart(); P.Ecart();
} }
func (P *Parser) ParseExpression() { func (P *Parser) ParseDeclaration() {
P.Trace("Expression"); P.Trace("Declaration");
indent := P.indent; indent := P.indent;
P.ParseBinaryExpr(1); 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(P.beg, "declaration expected");
}
if indent != P.indent { if indent != P.indent {
panic "imbalanced tracing code"; panic "imbalanced tracing code"
} }
P.Ecart(); P.Ecart();
} }
// ----------------------------------------------------------------------------
// Program
func (P *Parser) ParseProgram() { func (P *Parser) ParseProgram() {
P.Trace("Program"); P.Trace("Program");
P.OpenScope(); P.OpenScope();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7