2003/06/05 01:17:48

darcs-hash:20040130070047-2ba56-d0c42f61cb61a2dd526821831e9f2d4cbb2ef7bb.gz

diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java
index 67cb0a1..ced2039 100644 (file)
--- a/src/org/xwt/js/Parser.java
+++ b/src/org/xwt/js/Parser.java
@@ -63,19 +63,8 @@ public class Parser extends Lexer implements OpCodes {
     }
 
     /** parses the largest possible expression */
-    public ForthBlock parseMaximalForthBlock() throws IOException { return parseMaximalForthBlock(null, -1); }
-    public ForthBlock parseMaximalForthBlock(ForthBlock prefix, int minPrecedence) throws IOException {
-       while(true) {
-           if (peekToken() == -1) break;
-           ForthBlock save = prefix;
-           prefix = parseSingleForthBlock(prefix, minPrecedence);
-           if (save == prefix) break;
-           if (prefix == null) throw new ParserException("parseSingleForthBlock() returned null");
-       }
-       return prefix;
-    }
-
-    public ForthBlock parseSingleForthBlock(ForthBlock prefix, int minPrecedence) throws IOException {
+    public ForthBlock parseExpr() throws IOException { return parseExpr(null, -1); }
+    public ForthBlock parseExpr(ForthBlock prefix, int minPrecedence) throws IOException {
        ForthBlock e1 = null, e2 = null, e3 = null, head = null, tail = null, ret = null;
 
        int tok = peekToken();
@@ -100,14 +89,14 @@ public class Parser extends Lexer implements OpCodes {
                if (peekToken() == ASSIGN) {
                    b.add(b.LITERAL, name);
                    consume(ASSIGN);
-                   b.add(b.EXPR, parseMaximalForthBlock());
+                   b.add(b.EXPR, parseExpr());
                    b.add(b.PUT);
                    b.add(b.POP);
                }
                if (peekToken() != COMMA) break;
                consume(COMMA);
            }
-           return parseSingleForthBlock(b, minPrecedence);
+           return parseExpr(b, minPrecedence);
        }
 
        case IN: pushBackToken(); return prefix;
@@ -116,15 +105,15 @@ public class Parser extends Lexer implements OpCodes {
            if (prefix != null) { pushBackToken(); return prefix; }
            ForthBlock b = new ForthBlock(curLine, sourceName);
            consume(LP);
-           b.add(b.EXPR, parseMaximalForthBlock());
+           b.add(b.EXPR, parseExpr());
            consume(RP);
            b.add(b.JF, new Integer(3));
            b.add(b.EXPR, parseStatement(false));
            b.add(b.JMP, new Integer(2));
-           if (peekToken() != ELSE) return parseSingleForthBlock(b.add(b.LITERAL, null), minPrecedence);
+           if (peekToken() != ELSE) return parseExpr(b.add(b.LITERAL, null), minPrecedence);
            consume(ELSE);
            b.add(b.EXPR, parseStatement(false));
-           return parseSingleForthBlock(b, minPrecedence);
+           return parseExpr(b, minPrecedence);
        }
 
            // FIXME: ugly hack!!
@@ -142,60 +131,60 @@ public class Parser extends Lexer implements OpCodes {
            {
                ForthBlock b = (ForthBlock)prefix;
                b.set(b.size() - 1, b.GET_PRESERVE, new Boolean(true));
-               b.add(b.EXPR, parseMaximalForthBlock(null, precedence[tok]));
+               b.add(b.EXPR, parseExpr(null, precedence[tok]));
                b.add(tok);
                b.add(b.PUT);
                b.add(b.SWAP);
                b.add(b.POP);
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            }
 
        case INC: case DEC:
            if (prefix == null) {
                // prefix
-               ForthBlock b = (ForthBlock)parseMaximalForthBlock(null, precedence[tok]);
+               ForthBlock b = (ForthBlock)parseExpr(null, precedence[tok]);
                b.set(b.size() - 1, tok, new Boolean(true));
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            } else {
                // postfix
                ForthBlock b = (ForthBlock)prefix;
                b.set(b.size() - 1, tok, new Boolean(false));
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            }
 
        case LP:
            if (prefix == null) {  // grouping
-               ForthBlock b = new ForthBlock(curLine, sourceName, ForthBlock.EXPR, parseMaximalForthBlock());
+               ForthBlock b = new ForthBlock(curLine, sourceName, ForthBlock.EXPR, parseExpr());
                consume(RP);
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
 
            } else {  // invocation
                ForthBlock b = new ForthBlock(curLine, sourceName);
                int i = 0;
                b.add(b.EXPR, prefix);
                while(peekToken() != RP) {
-                   b.add(b.EXPR, parseMaximalForthBlock());
+                   b.add(b.EXPR, parseExpr());
                    i++;
                    if (peekToken() == RP) break;
                    consume(COMMA);
                }
                consume(RP);
                b.add(b.CALL, new Integer(i));
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            }
 
        case BANG: case BITNOT: case INSTANCEOF: case TYPEOF: {
            if (prefix != null) { pushBackToken(); return prefix; }
            ForthBlock b = new ForthBlock(curLine, sourceName);
-           b.add(b.EXPR, parseMaximalForthBlock(null, precedence[tok]));
+           b.add(b.EXPR, parseExpr(null, precedence[tok]));
            b.add(tok);
-           return parseSingleForthBlock(b, minPrecedence);
+           return parseExpr(b, minPrecedence);
        }
 
        case SUB:
            if (prefix == null && peekToken() == NUMBER) {
                getToken();
-               return parseSingleForthBlock(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, new Double(number.doubleValue() * -1)), minPrecedence);
+               return parseExpr(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, new Double(number.doubleValue() * -1)), minPrecedence);
            } // else fall through
         case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH:
        case RSH: case URSH: case ADD: case MUL: case DIV: case MOD:
@@ -203,9 +192,9 @@ public class Parser extends Lexer implements OpCodes {
            if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression");
            ForthBlock b = new ForthBlock(curLine, sourceName);
            b.add(b.EXPR, prefix);
-           b.add(b.EXPR, parseMaximalForthBlock(null, precedence[tok]));
+           b.add(b.EXPR, parseExpr(null, precedence[tok]));
            b.add(tok);
-           return parseSingleForthBlock(b, minPrecedence);
+           return parseExpr(b, minPrecedence);
        }
 
            // includes short-circuit logic
@@ -216,8 +205,8 @@ public class Parser extends Lexer implements OpCodes {
            b.add(b.EXPR, prefix);
            b.add(tok == AND ? b.JF : b.JT, new Integer(3));
            b.add(b.POP);
-           b.add(b.EXPR, parseMaximalForthBlock(null, precedence[tok]));
-           return parseSingleForthBlock(b, minPrecedence);
+           b.add(b.EXPR, parseExpr(null, precedence[tok]));
+           return parseExpr(b, minPrecedence);
        }
 
        case WITH: throw new ParserException("XWT does not allow the WITH keyword");
@@ -225,21 +214,21 @@ public class Parser extends Lexer implements OpCodes {
 
        case NUMBER:
            if (prefix != null) { pushBackToken(); return prefix; }
-           return parseSingleForthBlock(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, number), minPrecedence);
+           return parseExpr(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, number), minPrecedence);
 
        case STRING:
            if (prefix != null) { pushBackToken(); return prefix; }
-           return parseSingleForthBlock(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, string), minPrecedence);
+           return parseExpr(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, string), minPrecedence);
 
        case NULL: case TRUE: case FALSE: case NOP:
            if (prefix != null) { pushBackToken(); return prefix; }
-           return parseSingleForthBlock(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, (tok == NULL || tok == NOP) ? null : new Boolean(tok == TRUE)), minPrecedence);
+           return parseExpr(new ForthBlock(curLine, sourceName, ForthBlock.LITERAL, (tok == NULL || tok == NOP) ? null : new Boolean(tok == TRUE)), minPrecedence);
 
        case COMMA: pushBackToken(); return prefix;
 
        case Tokens.THIS:
            if (prefix != null) { pushBackToken(); return prefix; } 
-           return parseSingleForthBlock(new ForthBlock(curLine, sourceName, OpCodes.THIS, null), minPrecedence);
+           return parseExpr(new ForthBlock(curLine, sourceName, OpCodes.THIS, null), minPrecedence);
 
        case NAME: {
            if (prefix != null) { pushBackToken(); return prefix; }
@@ -249,16 +238,16 @@ public class Parser extends Lexer implements OpCodes {
                consume(ASSIGN);
                b.add(OpCodes.THIS);
                b.add(ForthBlock.LITERAL, name);
-               b.add(ForthBlock.EXPR, parseMaximalForthBlock(null, minPrecedence));
+               b.add(ForthBlock.EXPR, parseExpr(null, minPrecedence));
                b.add(ForthBlock.PUT);
                b.add(ForthBlock.SWAP);
                b.add(ForthBlock.POP);
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            } else {
                b.add(OpCodes.THIS);
                b.add(ForthBlock.LITERAL, name);
                b.add(ForthBlock.GET);
-               return parseSingleForthBlock(parseMaximalForthBlock(b, minPrecedence), minPrecedence);
+               return parseExpr(parseExpr(b, minPrecedence), minPrecedence);
            }
        }
 
@@ -269,7 +258,7 @@ public class Parser extends Lexer implements OpCodes {
            b.add(b.EXPR, prefix);
            if (peekToken() == ASSIGN) {
                consume(ASSIGN);
-               ForthBlock val = parseMaximalForthBlock();
+               ForthBlock val = parseExpr();
                b.add(b.LITERAL, target);
                b.add(b.EXPR, val);
                b.add(b.PUT);
@@ -279,7 +268,7 @@ public class Parser extends Lexer implements OpCodes {
                b.add(b.LITERAL, target);
                b.add(b.GET);
            }
-           return parseSingleForthBlock(b, minPrecedence);
+           return parseExpr(b, minPrecedence);
        }
 
        case LB: {
@@ -288,30 +277,30 @@ public class Parser extends Lexer implements OpCodes {
                b.add(b.ARRAY, new Integer(0));
                int i = 0;
                while(true) {
-                   ForthBlock e = parseMaximalForthBlock();
-                   if (e == null && peekToken() == RB) { consume(RB); return parseSingleForthBlock(b, minPrecedence); }
+                   ForthBlock e = parseExpr();
+                   if (e == null && peekToken() == RB) { consume(RB); return parseExpr(b, minPrecedence); }
                    b.add(b.LITERAL, new Integer(i++));
                    if (e == null) b.add(b.LITERAL, null);
                    else b.add(b.EXPR, e);
                    b.add(b.PUT);
                    b.add(b.POP);
-                   if (peekToken() == RB) { consume(RB); return parseSingleForthBlock(b, minPrecedence); }
+                   if (peekToken() == RB) { consume(RB); return parseExpr(b, minPrecedence); }
                    consume(COMMA);
                }
            } else {
                b.add(b.EXPR, prefix);
-               b.add(b.EXPR, parseMaximalForthBlock());
+               b.add(b.EXPR, parseExpr());
                consume(RB);
                if (peekToken() == ASSIGN) {
                    consume(ASSIGN);
-                   b.add(b.EXPR, parseMaximalForthBlock());
+                   b.add(b.EXPR, parseExpr());
                    b.add(b.PUT);
                    b.add(b.SWAP);
                    b.add(b.POP);
                } else {
                    b.add(b.GET);
                }
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            }
        }
 
@@ -319,18 +308,18 @@ public class Parser extends Lexer implements OpCodes {
            if (prefix != null) { pushBackToken(); return prefix; }
            ForthBlock b = new ForthBlock(curLine, sourceName);
            b.add(b.OBJECT, null);
-           if (peekToken() == RC) { consume(RC); return parseSingleForthBlock(b, minPrecedence); }
+           if (peekToken() == RC) { consume(RC); return parseExpr(b, minPrecedence); }
            while(true) {
                if (peekToken() != NAME && peekToken() != STRING) throw new Error("expected NAME or STRING");
                getToken();
                b.add(b.LITERAL, string);
                consume(COLON);
-               b.add(b.EXPR, parseMaximalForthBlock());
+               b.add(b.EXPR, parseExpr());
                b.add(b.PUT);
                b.add(b.POP);
-               if (peekToken() == RC) { consume(RC); return parseSingleForthBlock(b, minPrecedence); }
+               if (peekToken() == RC) { consume(RC); return parseExpr(b, minPrecedence); }
                consume(COMMA);
-               if (peekToken() == RC) { consume(RC); return parseSingleForthBlock(b, minPrecedence); }
+               if (peekToken() == RC) { consume(RC); return parseExpr(b, minPrecedence); }
            }
        }
            
@@ -338,11 +327,11 @@ public class Parser extends Lexer implements OpCodes {
            ForthBlock b = new ForthBlock(curLine, sourceName);
            b.add(b.EXPR, prefix);
            b.add(b.JF, new Integer(3));
-           b.add(b.EXPR, parseMaximalForthBlock());
+           b.add(b.EXPR, parseExpr());
            b.add(b.JMP, new Integer(2));
            consume(COLON);
-           b.add(b.EXPR, parseMaximalForthBlock());
-           return parseSingleForthBlock(b, minPrecedence);
+           b.add(b.EXPR, parseExpr());
+           return parseExpr(b, minPrecedence);
        }
            
        case Tokens.FUNCTION: {
@@ -395,7 +384,7 @@ public class Parser extends Lexer implements OpCodes {
            // pop off the arguments array
            b.add(b.POP);
            parseStatement(true, b);
-           return parseSingleForthBlock(new ForthBlock(curLine, sourceName, OpCodes.FUNCTION, b), minPrecedence);
+           return parseExpr(new ForthBlock(curLine, sourceName, OpCodes.FUNCTION, b), minPrecedence);
        }
            
        case WHILE: {
@@ -406,7 +395,7 @@ public class Parser extends Lexer implements OpCodes {
            r.add(loop.LOOP, loop);
            r.add(r.LITERAL, null);
 
-           loop.add(loop.EXPR, parseMaximalForthBlock());
+           loop.add(loop.EXPR, parseExpr());
            loop.add(loop.JT, new Integer(2));
            loop.add(Lexer.BREAK);
            consume(RP);
@@ -414,7 +403,7 @@ public class Parser extends Lexer implements OpCodes {
 
            // if we fall out of the end, definately continue
            loop.add(CONTINUE);
-           return parseSingleForthBlock(r, minPrecedence);
+           return parseExpr(r, minPrecedence);
        }
 
        case SWITCH: {
@@ -424,7 +413,7 @@ public class Parser extends Lexer implements OpCodes {
            ForthBlock loop = new ForthBlock(curLine, sourceName);
            r.add(loop.LOOP, loop);
            r.add(r.LITERAL, null);
-           loop.add(loop.EXPR, parseMaximalForthBlock());
+           loop.add(loop.EXPR, parseExpr());
            consume(RP);
            consume(LC);
            while(true) {
@@ -432,7 +421,7 @@ public class Parser extends Lexer implements OpCodes {
                tok = getToken();
                if (tok == CASE) {
                    loop.add(loop.DUP);
-                   loop.add(loop.EXPR, parseMaximalForthBlock());
+                   loop.add(loop.EXPR, parseExpr());
                    loop.add(EQ);
                    loop.add(loop.JF, new Integer(2));
                } else if (tok != DEFAULT) throw new ParserException("expected CASE or DEFAULT");
@@ -446,7 +435,7 @@ public class Parser extends Lexer implements OpCodes {
                if (peekToken() == RC) {
                    consume(RC);
                    r.add(BREAK);
-                   return parseSingleForthBlock(r, minPrecedence);
+                   return parseExpr(r, minPrecedence);
                }
            }
        }
@@ -461,13 +450,13 @@ public class Parser extends Lexer implements OpCodes {
            parseStatement(false, loop);
            consume(WHILE);
            consume(LP);
-           loop.add(loop.EXPR, parseMaximalForthBlock());
+           loop.add(loop.EXPR, parseExpr());
            loop.add(loop.JT, new Integer(2));
            loop.add(Lexer.BREAK);
            loop.add(Lexer.CONTINUE);
            consume(RP);
            consume(SEMI);
-           return parseSingleForthBlock(r, minPrecedence);
+           return parseExpr(r, minPrecedence);
        }
 
        case TRY: {
@@ -486,7 +475,7 @@ public class Parser extends Lexer implements OpCodes {
            }
            if (tok == FINALLY) getToken();
 
-           return parseSingleForthBlock(tryBlock, minPrecedence);
+           return parseExpr(tryBlock, minPrecedence);
        }
 
        case FOR: {
@@ -503,7 +492,7 @@ public class Parser extends Lexer implements OpCodes {
            if (forIn) {
                consume(NAME);
                consume(IN);
-               b.add(b.EXPR, parseMaximalForthBlock());
+               b.add(b.EXPR, parseExpr());
                b.add(b.PUSHKEYS);
                b.add(b.LITERAL, "length");
                b.add(b.GET);
@@ -523,21 +512,21 @@ public class Parser extends Lexer implements OpCodes {
                b2.add(b.PUT);
                b2.add(b.EXPR, parseStatement(false));
                b2.add(b.LITERAL, null);
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
                
            } else {
                ForthBlock b2 = new ForthBlock(curLine, sourceName);
                b.add(b.SCOPE, b2);
 
-               e1 = parseMaximalForthBlock();
+               e1 = parseExpr();
                if (e1 == null) e1 = new ForthBlock(curLine, sourceName, b.LITERAL, null);
 
                b2.add(b.EXPR, e1);
                b2.add(b.POP);
                consume(SEMI);
-               e2 = parseMaximalForthBlock();
+               e2 = parseExpr();
                consume(SEMI);
-               e3 = parseMaximalForthBlock();
+               e3 = parseExpr();
                consume(RP);
 
                if (e2 == null) e2 = new ForthBlock(curLine, sourceName, b.LITERAL, null);
@@ -553,7 +542,7 @@ public class Parser extends Lexer implements OpCodes {
                b3.add(b.JT, new Integer(2));
                b3.add(BREAK);
                parseStatement(false, b3);
-               return parseSingleForthBlock(b, minPrecedence);
+               return parseExpr(b, minPrecedence);
            }
        }
            
@@ -587,7 +576,7 @@ public class Parser extends Lexer implements OpCodes {
                getToken();
                ForthBlock r = new ForthBlock(curLine, sourceName);
                if (tok == RETURN && peekToken() == SEMI) r.add(b.LITERAL, null);
-               else r.add(b.EXPR, parseMaximalForthBlock());
+               else r.add(b.EXPR, parseExpr());
                consume(SEMI);
                r.add(tok);
                smt = r;
@@ -626,7 +615,7 @@ public class Parser extends Lexer implements OpCodes {
 
            case -1:
            default:
-               smt = parseMaximalForthBlock();
+               smt = parseExpr();
                if (smt == null) return block.size() == 0 ? null : ret;
                if (peekToken() == SEMI) getToken();
                break;