2003/07/09 01:19:45

darcs-hash:20040130070340-aa32f-f75bcda4c93cef3af88f69a59d0e0d980bc3aa70.gz

diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java
index 782c756..4abbdea 100644 (file)
--- a/src/org/xwt/js/Parser.java
+++ b/src/org/xwt/js/Parser.java
@@ -83,6 +83,8 @@ class Parser extends Lexer implements ByteCodes {
 
     static byte[] precedence = new byte[MAX_TOKEN + 1];
     static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1];
+    // Use this as the precedence when we want anything up to the comma
+    private final static int NO_COMMA = 2;
     static {
         isRightAssociative[ASSIGN] =
             isRightAssociative[ASSIGN_BITOR] =
@@ -97,6 +99,8 @@ class Parser extends Lexer implements ByteCodes {
             isRightAssociative[ASSIGN_DIV] =
             isRightAssociative[ASSIGN_MOD] = true;
 
+        precedence[COMMA] = 1;
+        // 2 is intentionally left unassigned. we use minPrecedence==2 for comma separated lists
         precedence[ASSIGN] =
             precedence[ASSIGN_BITOR] =
             precedence[ASSIGN_BITXOR] =
@@ -108,24 +112,20 @@ class Parser extends Lexer implements ByteCodes {
             precedence[ASSIGN_SUB] =
             precedence[ASSIGN_MUL] =
             precedence[ASSIGN_DIV] =
-            precedence[ASSIGN_MOD] = 1;
-        precedence[HOOK] = 2;
-        precedence[COMMA] = 3;
-        precedence[OR] = precedence[AND] = precedence[BANG] = 4;
-        precedence[GT] = precedence[GE] = 5;
-        precedence[BITOR] = 6;
-        precedence[BITXOR] = 7;
-        precedence[BITAND] = 8;
-        precedence[EQ] = precedence[NE] = 9;
-        precedence[LT] = precedence[LE] = precedence[TYPEOF] = 10;
-        precedence[SHEQ] = precedence[SHNE] = 11;
+            precedence[ASSIGN_MOD] = 3;
+        precedence[HOOK] = 4;
+        precedence[OR] = 5;
+        precedence[AND] = 6;
+        precedence[BITOR] = 7;
+        precedence[BITXOR] = 8;
+        precedence[BITAND] = 9;
+        precedence[EQ] = precedence[NE] = precedence[SHEQ] = precedence[SHNE] = 10;
+        precedence[LT] = precedence[LE] = precedence[GT] = precedence[GE] = 11;
         precedence[LSH] = precedence[RSH] = precedence[URSH] = 12;
-        precedence[ADD] = precedence[SUB] = 13;
-        precedence[MUL] = precedence[DIV] = precedence[MOD] = 14;
-        precedence[BITNOT] =  15;
-        precedence[INC] = precedence[DEC] = 16;
-        precedence[LP] = 17;
-        precedence[DOT] = precedence[LB] = 18;
+        precedence[ADD] = precedence[SUB] = 12;
+        precedence[MUL] = precedence[DIV] = precedence[MOD] = 13;
+        precedence[BITNOT] =  precedence[BANG] = precedence[TYPEOF] = 14;
+        precedence[DOT] = precedence[LB] = precedence[LP] =  precedence[INC] = precedence[DEC] = 15;
     }
 
 
@@ -172,7 +172,7 @@ class Parser extends Lexer implements ByteCodes {
                     if (peekToken() == COMMA || peekToken() == RB)
                         b.add(parserLine, LITERAL, null);                   // for stuff like [1,,2,]
                     else
-                        startExpr(b, -1);                                   // push the value onto the stack
+                        startExpr(b, NO_COMMA);                             // push the value onto the stack
                     b.add(parserLine, PUT);                                 // put it into the array
                     b.add(parserLine, POP);                                 // discard the value remaining on the stack
                     if (peekToken() == RB) break;
@@ -218,7 +218,7 @@ class Parser extends Lexer implements ByteCodes {
                     getToken();
                     b.add(parserLine, LITERAL, string);                          // grab the key
                     consume(COLON);
-                    startExpr(b, -1);                                            // grab the value
+                    startExpr(b, NO_COMMA);                                      // grab the value
                     b.add(parserLine, PUT);                                      // put the value into the object
                     b.add(parserLine, POP);                                      // discard the remaining value
                     if (peekToken() == RC) break;
@@ -231,7 +231,7 @@ class Parser extends Lexer implements ByteCodes {
         case NAME: {
             b.add(parserLine, TOPSCOPE);
             b.add(parserLine, LITERAL, string);
-            continueExprAfterAssignable(b);
+            continueExprAfterAssignable(b,minPrecedence);
             break;
         }
         case FUNCTION: {
@@ -298,19 +298,22 @@ class Parser extends Lexer implements ByteCodes {
      *  expression that modifies the assignable.  This method always
      *  decreases the stack depth by exactly one element.
      */
-    private void continueExprAfterAssignable(CompiledFunctionImpl b) throws IOException {
+    private void continueExprAfterAssignable(CompiledFunctionImpl b,int minPrecedence) throws IOException {
         int saveParserLine = parserLine;
-        _continueExprAfterAssignable(b);
+        _continueExprAfterAssignable(b,minPrecedence);
         parserLine = saveParserLine;
     }
-    private void _continueExprAfterAssignable(CompiledFunctionImpl b) throws IOException {
+    private void _continueExprAfterAssignable(CompiledFunctionImpl b,int minPrecedence) throws IOException {
         if (b == null) throw new Error("got null b; this should never happen");
         int tok = getToken();
+        if (minPrecedence != -1 && (precedence[tok] < minPrecedence || (precedence[tok] == minPrecedence && !isRightAssociative[tok])))
+            // force the default case
+            tok = -1;
         switch(tok) {
         case ASSIGN_BITOR: case ASSIGN_BITXOR: case ASSIGN_BITAND: case ASSIGN_LSH: case ASSIGN_RSH: case ASSIGN_URSH:
         case ASSIGN_ADD: case ASSIGN_SUB: case ASSIGN_MUL: case ASSIGN_DIV: case ASSIGN_MOD: {
             b.add(parserLine, GET_PRESERVE);
-            startExpr(b, -1);
+            startExpr(b,  precedence[tok]);
             // tok-1 is always s/^ASSIGN_// (0 is BITOR, 1 is ASSIGN_BITOR, etc) 
             b.add(parserLine, tok - 1, tok-1==ADD ? new Integer(2) : null);
             b.add(parserLine, PUT);
@@ -323,7 +326,7 @@ class Parser extends Lexer implements ByteCodes {
             break;
         }
         case ASSIGN: {
-            startExpr(b, -1);
+            startExpr(b, precedence[tok]);
             b.add(parserLine, PUT);
             b.add(parserLine, SWAP);
             b.add(parserLine, POP);
@@ -409,27 +412,33 @@ class Parser extends Lexer implements ByteCodes {
         case DOT: {
             consume(NAME);
             b.add(parserLine, LITERAL, string);
-            continueExprAfterAssignable(b);
+            continueExprAfterAssignable(b,minPrecedence);
             break;
         }
         case LB: { // subscripting (not array constructor)
             startExpr(b, -1);
             consume(RB);
-            continueExprAfterAssignable(b);
+            continueExprAfterAssignable(b,minPrecedence);
             break;
         }
         case HOOK: {
             b.add(parserLine, JF, new Integer(0));                // jump to the if-false expression
             int size = b.size();
-            startExpr(b, -1);                                     // write the if-true expression
+            startExpr(b, minPrecedence);                          // write the if-true expression
             b.add(parserLine, JMP, new Integer(0));               // if true, jump *over* the if-false expression     
             b.set(size - 1, new Integer(b.size() - size + 1));    // now we know where the target of the jump is
             consume(COLON);
             size = b.size();
-            startExpr(b, -1);                                     // write the if-false expression
+            startExpr(b, minPrecedence);                          // write the if-false expression
             b.set(size - 1, new Integer(b.size() - size + 1));    // this is the end; jump to here
             break;
         }
+        case COMMA: {
+            // pop the result of the previous expression, it is ignored
+            b.add(parserLine,POP);
+            startExpr(b,-1);
+            break;
+        }
         default: {
             pushBackToken();
             return;
@@ -445,7 +454,7 @@ class Parser extends Lexer implements ByteCodes {
         while(peekToken() != RP) {
             i++;
             if (peekToken() != COMMA) {
-                startExpr(b, -1);
+                startExpr(b, NO_COMMA);
                 if (peekToken() == RP) break;
             }
             consume(COMMA);
@@ -504,7 +513,7 @@ class Parser extends Lexer implements ByteCodes {
                 b.add(parserLine, DECLARE, string);               // declare it
                 if (peekToken() == ASSIGN) {                     // if there is an '=' after the variable name
                     consume(ASSIGN);
-                    startExpr(b, -1);
+                    startExpr(b, NO_COMMA);
                     b.add(parserLine, PUT);                      // assign it
                     b.add(parserLine, POP);                      // clean the stack
                 } else {