- more cleanups (simpler code for optional semi's, bug fixes)

R=r
OCL=16869
CL=16869

diff --git a/usr/gri/pretty/parser.go b/usr/gri/pretty/parser.go
index fde763595f7b0996ecbfd4f243ef1d37588a2c71..6ccfe1dadbd7a04d38d92517ca9d0b219362e57d 100644 (file)
--- a/usr/gri/pretty/parser.go
+++ b/usr/gri/pretty/parser.go
@@ -15,10 +15,10 @@ export type Parser struct {
        tokchan *<-chan *Scanner.Token;
        
        // Scanner.Token
-       old int;  // previous token
        pos int;  // token source position
        tok int;  // one token look-ahead
        val string;  // token value (for IDENT, NUMBER, STRING only)
+       semi bool;  // true if a semicolon was inserted by the previous statement
 
        // Nesting level
        level int;  // 0 = global scope, -1 = function scope of global functions, etc.
@@ -54,13 +54,13 @@ func (P *Parser) Ecart() {
 
 
 func (P *Parser) Next() {
-       P.old = P.tok;
        if P.tokchan == nil {
                P.pos, P.tok, P.val = P.scanner.Scan();
        } else {
                t := <-P.tokchan;
                P.tok, P.pos, P.val = t.tok, t.pos, t.val;
        }
+       P.semi = false;
        if P.verbose {
                P.PrintIndent();
                print("[", P.pos, "] ", Scanner.TokenName(P.tok), "\n");
@@ -73,7 +73,6 @@ func (P *Parser) Open(verbose bool, scanner *Scanner.Scanner, tokchan *<-chan *S
        P.indent = 0;
        P.scanner = scanner;
        P.tokchan = tokchan;
-       P.old = Scanner.ILLEGAL;
        P.Next();
        P.level = 0;
 }
@@ -92,8 +91,8 @@ func (P *Parser) Expect(tok int) {
 }
 
 
-func (P *Parser) Optional(tok int) {
-       if P.tok == tok {
+func (P *Parser) OptSemicolon() {
+       if P.tok == Scanner.SEMICOLON {
                P.Next();
        }
 }
@@ -115,22 +114,10 @@ func (P *Parser) CloseScope() {
 
 func (P *Parser) TryType() (typ AST.Type, ok bool);
 func (P *Parser) ParseExpression() AST.Expr;
-func (P *Parser) TryStatement() (stat AST.Stat, ok bool);
+func (P *Parser) ParseStatement() AST.Stat;
 func (P *Parser) ParseDeclaration() AST.Node;
 
 
-func (P *Parser) OptSemicolon(tok int) {
-       P.Trace("OptSemicolon");
-       if P.tok == Scanner.SEMICOLON {
-               P.Next();
-       } else if P.level != 0 || P.old != tok || P.tok != tok {
-               // TODO FIX THIS
-               // P.Expect(Scanner.SEMICOLON);
-       }
-       P.Ecart();
-}
-
-
 func (P *Parser) ParseIdent() *AST.Ident {
        P.Trace("Ident");
 
@@ -454,7 +441,7 @@ func (P *Parser) ParseStructType() *AST.StructType {
                                P.Expect(Scanner.SEMICOLON);
                        }
                }
-               P.Optional(Scanner.SEMICOLON);
+               P.OptSemicolon();
                P.Expect(Scanner.RBRACE);
        }
 
@@ -503,31 +490,16 @@ func (P *Parser) TryType() (typ_ AST.Type, ok_ bool) {
 // ----------------------------------------------------------------------------
 // Blocks
 
-func (P *Parser) ParseStatement() AST.Stat {
-       P.Trace("Statement");
-       
-       stat, ok := P.TryStatement();
-       if ok {
-               P.OptSemicolon(Scanner.RBRACE);
-       } else {
-               P.Error(P.pos, "statement expected");
-               P.Next();  // make progress
-       }
-       
-       P.Ecart();
-       return stat;
-}
-
-
 func (P *Parser) ParseStatementList() *AST.List {
        P.Trace("StatementList");
        
        stats := AST.NewList();
-       for {
-               stat, ok := P.TryStatement();
-               if ok {
-                       stats.Add(stat);
-                       P.Optional(Scanner.SEMICOLON);
+       for P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
+               stats.Add(P.ParseStatement());
+               if P.tok == Scanner.SEMICOLON {
+                       P.Next();
+               } else if P.semi {
+                       P.semi = false;  // consume inserted ";"
                } else {
                        break;
                }
@@ -546,13 +518,13 @@ func (P *Parser) ParseBlock() *AST.Block {
        
        P.Expect(Scanner.LBRACE);
        P.OpenScope();
-       
-       if P.tok != Scanner.RBRACE && P.tok != Scanner.SEMICOLON {
+       if P.tok != Scanner.RBRACE {
                block.stats = P.ParseStatementList();
        }
-       P.Optional(Scanner.SEMICOLON);
+       P.OptSemicolon();
        P.CloseScope();
        P.Expect(Scanner.RBRACE);
+       P.semi = true;  // allow optional semicolon
        
        P.Ecart();
        return block;
@@ -801,14 +773,15 @@ func (P *Parser) ParsePrimaryExpr() AST.Expr {
        P.Trace("PrimaryExpr");
        
        x := P.ParseOperand();
-       L: for {
+       for {
                switch P.tok {
                case Scanner.PERIOD: x = P.ParseSelectorOrTypeGuard(x);
                case Scanner.LBRACK: x = P.ParseIndexOrSlice(x);
                case Scanner.LPAREN: x = P.ParseCall(x);
-               default: break L;
+               default: goto exit;
                }
        }
+exit:
 
        P.Ecart();
        return x;
@@ -899,6 +872,7 @@ func (P *Parser) ParseSimpleStat() AST.Stat {
                        l.ident = AST.NIL;
                }
                P.Next();  // consume ":"
+               P.semi = true;  // allow optional semicolon
                stat = l;
                
        case
@@ -1083,14 +1057,8 @@ func (P *Parser) ParseCaseClause() *AST.CaseClause {
        P.Trace("CaseClause");
 
        clause := P.ParseCase();
-       if P.tok != Scanner.FALLTHROUGH && P.tok != Scanner.RBRACE {
+       if P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE {
                clause.stats = P.ParseStatementList();
-               P.Optional(Scanner.SEMICOLON);
-       }
-       if P.tok == Scanner.FALLTHROUGH {
-               P.Next();
-               clause.falls = true;
-               P.Optional(Scanner.SEMICOLON);
        }
        
        P.Ecart();
@@ -1107,10 +1075,11 @@ func (P *Parser) ParseSwitchStat() *AST.SwitchStat {
        stat.cases = AST.NewList();
        
        P.Expect(Scanner.LBRACE);
-       for P.tok == Scanner.CASE || P.tok == Scanner.DEFAULT {
+       for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
                stat.cases.Add(P.ParseCaseClause());
        }
        P.Expect(Scanner.RBRACE);
+       P.semi = true;  // allow optional semicolon
 
        P.Ecart();
        return stat;
@@ -1122,19 +1091,10 @@ func (P *Parser) ParseCommCase() {
   
   if P.tok == Scanner.CASE {
        P.Next();
-       if P.tok == Scanner.GTR {
-               // send
+       P.ParseExpression();
+       if P.tok == Scanner.ASSIGN || P.tok == Scanner.DEFINE {
                P.Next();
-               P.ParseExpression();
-               P.Expect(Scanner.EQL);
-               P.ParseExpression();
-       } else {
-               // receive
-               if P.tok != Scanner.LSS {
-                       P.ParseIdent();
-                       P.Expect(Scanner.ASSIGN);
-               }
-               P.Expect(Scanner.LSS);
+               P.Expect(Scanner.ARROW);
                P.ParseExpression();
        }
   } else {
@@ -1152,26 +1112,12 @@ func (P *Parser) ParseCommClause() {
        P.ParseCommCase();
        if P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE {
                P.ParseStatementList();
-               P.Optional(Scanner.SEMICOLON);
        }
        
        P.Ecart();
 }
 
 
-func (P *Parser) ParseRangeStat() {
-       P.Trace("RangeStat");
-       
-       P.Expect(Scanner.RANGE);
-       P.ParseIdentList();
-       P.Expect(Scanner.DEFINE);
-       P.ParseExpression();
-       P.ParseBlock();
-       
-       P.Ecart();
-}
-
-
 func (P *Parser) ParseSelectStat() {
        P.Trace("SelectStat");
        
@@ -1180,18 +1126,46 @@ func (P *Parser) ParseSelectStat() {
        for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
                P.ParseCommClause();
        }
-       P.Next();
+       P.Expect(Scanner.RBRACE);
+       P.semi = true;  // allow optional semicolon
        
        P.Ecart();
 }
 
 
-func (P *Parser) TryStatement() (stat_ AST.Stat, ok_ bool) {
-       P.Trace("Statement (try)");
+func (P *Parser) ParseFallthroughStat() {
+       P.Trace("FallthroughStat");
+       
+       P.Expect(Scanner.FALLTHROUGH);
+
+       P.Ecart();
+}
+
+
+func (P *Parser) ParseEmptyStat() {
+       P.Trace("EmptyStat");
+       P.Ecart();
+}
+
+
+func (P *Parser) ParseRangeStat() {
+       P.Trace("RangeStat");
+       
+       P.Expect(Scanner.RANGE);
+       P.ParseIdentList();
+       P.Expect(Scanner.DEFINE);
+       P.ParseExpression();
+       P.ParseBlock();
+       
+       P.Ecart();;
+}
+
+
+func (P *Parser) ParseStatement() AST.Stat {
+       P.Trace("Statement");
        indent := P.indent;
 
        var stat AST.Stat = AST.NIL;
-       res := true;
        switch P.tok {
        case Scanner.CONST, Scanner.TYPE, Scanner.VAR:
                stat = P.ParseDeclaration();
@@ -1218,16 +1192,17 @@ func (P *Parser) TryStatement() (stat_ AST.Stat, ok_ bool) {
                P.ParseRangeStat();
        case Scanner.SELECT:
                P.ParseSelectStat();
+       case Scanner.FALLTHROUGH:
+               P.ParseFallthroughStat();
        default:
-               // no statement found
-               res = false;
+               P.ParseEmptyStat();  // for complete tracing output only
        }
 
        if indent != P.indent {
                panic("imbalanced tracing code (Statement)");
        }
        P.Ecart();
-       return stat, res;
+       return stat;
 }
 
 
@@ -1284,6 +1259,7 @@ func (P *Parser) ParseTypeSpec(exported bool) *AST.TypeDecl {
        decl := new(AST.TypeDecl);
        decl.ident = P.ParseIdent();
        decl.typ = P.ParseType();
+       P.semi = true;  // allow optional semicolon
        
        P.Ecart();
        return decl;
@@ -1335,13 +1311,17 @@ func (P *Parser) ParseDecl(exported bool, keyword int) *AST.Declaration {
        P.Expect(keyword);
        if P.tok == Scanner.LPAREN {
                P.Next();
-               decl.decls.Add(P.ParseSpec(exported, keyword));
-               P.OptSemicolon(Scanner.RPAREN);
-               for P.tok != Scanner.RPAREN {
+               for P.tok != Scanner.RPAREN && P.tok != Scanner.EOF {
                        decl.decls.Add(P.ParseSpec(exported, keyword));
-                       P.OptSemicolon(Scanner.RPAREN);
+                       if P.tok == Scanner.SEMICOLON {
+                               P.Next();
+                       } else {
+                               break;
+                       }
                }
-               P.Next();  // consume ")"
+               P.Expect(Scanner.RPAREN);
+               P.semi = true;  // allow optional semicolon
+               
        } else {
                decl.decls.Add(P.ParseSpec(exported, keyword));
        }
@@ -1462,8 +1442,6 @@ func (P *Parser) ParseDeclaration() AST.Node {
                }
        }
 
-       P.OptSemicolon(Scanner.RBRACE);
-
        if indent != P.indent {
                panic("imbalanced tracing code (Declaration)");
        }
@@ -1491,11 +1469,12 @@ func (P *Parser) ParseProgram() *AST.Program {
                
                for P.tok == Scanner.IMPORT {
                        decls.Add(P.ParseDecl(false, Scanner.IMPORT));
-                       P.Optional(Scanner.SEMICOLON);
+                       P.OptSemicolon();
                }
                
                for P.tok != Scanner.EOF {
                        decls.Add(P.ParseDeclaration());
+                       P.OptSemicolon();
                }
                
                if P.level != 0 {