Attachment 91999 Details for Bug 221055 – proposed fix

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] proposed fix

parser-choiceexpr-fix_patch.txt (text/plain), 71.69 KB, created by Matthias Fuessel

on 2008-03-09 18:16:06 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Matthias Fuessel

Created: 2008-03-09 18:16:06 EDT

Size: 71.69 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jst.jsp.core
>Index: src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPELParser.java
>===================================================================
>RCS file: /cvsroot/webtools/sourceediting/plugins/org.eclipse.jst.jsp.core/src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPELParser.java,v
>retrieving revision 1.7
>diff -u -r1.7 JSPELParser.java
>--- src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPELParser.java	1 Oct 2005 13:56:46 -0000	1.7
>+++ src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPELParser.java	9 Mar 2008 21:34:20 -0000
>@@ -65,10 +65,10 @@
>           throw new ParseException();
>         }
>       }
>-                                                               jjtree.closeNodeScope(jjtn000, true);
>-                                                               jjtc000 = false;
>-                                                               jjtreeCloseNodeScope(jjtn000);
>-                                                               {if (true) return jjtn000;}
>+                                                                                 jjtree.closeNodeScope(jjtn000, true);
>+                                                                                 jjtc000 = false;
>+                                                                                 jjtreeCloseNodeScope(jjtn000);
>+                                                                                 {if (true) return jjtn000;}
>     } catch (Throwable jjte000) {
>           if (jjtc000) {
>             jjtree.clearNodeScope(jjtn000);
>@@ -481,9 +481,9 @@
>     try {
>       OrExpression();
>       jj_consume_token(COND);
>-      OrExpression();
>+      Expression();
>       jj_consume_token(COLON);
>-      OrExpression();
>+      Expression();
>     } catch (Throwable jjte000) {
>           if (jjtc000) {
>             jjtree.clearNodeScope(jjtn000);
>@@ -641,7 +641,7 @@
>         break;
>       default:
>         jj_la1[16] = jj_gen;
>-        if (jj_2_2(3)) {
>+        if (jj_2_2(2147483647)) {
>           FunctionInvocation();
>         } else {
>           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
>@@ -739,47 +739,36 @@
>         jjtree.openNodeScope(jjtn000);
>         jjtreeOpenNodeScope(jjtn000);Token prefix = null, name = null;
>     try {
>-      prefix = jj_consume_token(IDENTIFIER);
>-      jj_consume_token(COLON);
>-                                      jjtn000.setFullFunctionName(prefix.image + ":");
>-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
>-      case IDENTIFIER:
>-        name = jj_consume_token(IDENTIFIER);
>-        break;
>-      default:
>-        jj_la1[20] = jj_gen;
>+      if (jj_2_3(2)) {
>+        prefix = jj_consume_token(IDENTIFIER);
>+        jj_consume_token(COLON);
>+      } else {
>         
>       }
>+      name = jj_consume_token(IDENTIFIER);
>             if(null != prefix && null != name)
>                     jjtn000.setFullFunctionName(prefix.image + ":" + (null == name ? "" : name.image));
>             else if(null != name)
>                     jjtn000.setFullFunctionName(name.image);
>-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
>-      case LPAREN:
>-        jj_consume_token(LPAREN);
>-        Expression();
>-        label_8:
>-        while (true) {
>-          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
>-          case COMMA:
>-            
>-            break;
>-          default:
>-            jj_la1[21] = jj_gen;
>-            break label_8;
>-          }
>-          jj_consume_token(COMMA);
>-          Expression();
>+      jj_consume_token(LPAREN);
>+      Expression();
>+      label_8:
>+      while (true) {
>+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
>+        case COMMA:
>+          
>+          break;
>+        default:
>+          jj_la1[20] = jj_gen;
>+          break label_8;
>         }
>-        try {
>-          jj_consume_token(RPAREN);
>-        } catch (Exception e) {
>+        jj_consume_token(COMMA);
>+        Expression();
>+      }
>+      try {
>+        jj_consume_token(RPAREN);
>+      } catch (Exception e) {
> 
>-        }
>-        break;
>-      default:
>-        jj_la1[22] = jj_gen;
>-        
>       }
>     } catch (Throwable jjte000) {
>       if (jjtc000) {
>@@ -830,7 +819,7 @@
>         jj_consume_token(NULL);
>         break;
>       default:
>-        jj_la1[23] = jj_gen;
>+        jj_la1[21] = jj_gen;
>         jj_consume_token(-1);
>         throw new ParseException();
>       }
>@@ -856,32 +845,379 @@
>     finally { jj_save(1, xla); }
>   }
> 
>-  final private boolean jj_3R_10() {
>-    if (jj_scan_token(LPAREN)) return true;
>+  final private boolean jj_2_3(int xla) {
>+    jj_la = xla; jj_lastpos = jj_scanpos = token;
>+    try { return !jj_3_3(); }
>+    catch(LookaheadSuccess ls) { return true; }
>+    finally { jj_save(2, xla); }
>+  }
>+
>+  final private boolean jj_3R_38() {
>+    if (jj_3R_9()) return true;
>     return false;
>   }
> 
>   final private boolean jj_3R_9() {
>+    if (jj_3R_11()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_12()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3_3() {
>     if (jj_scan_token(IDENTIFIER)) return true;
>     if (jj_scan_token(COLON)) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_34() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_3_3()) jj_scanpos = xsp;
>+    if (jj_scan_token(IDENTIFIER)) return true;
>+    if (jj_scan_token(LPAREN)) return true;
>+    if (jj_3R_33()) return true;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_39()) { jj_scanpos = xsp; break; }
>+    }
>+    if (jj_scan_token(RPAREN)) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_37() {
>+    if (jj_3R_40()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_17() {
>+    if (jj_3R_19()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_20()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_36() {
>+    if (jj_scan_token(LBRACKET)) return true;
>+    if (jj_3R_33()) return true;
>+    if (jj_scan_token(RBRACKET)) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_33() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_3R_37()) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_38()) return true;
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_18() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(16)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(17)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(14)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(15)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(22)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(23)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(20)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(21)) return true;
>+    }
>+    }
>+    }
>+    }
>+    }
>+    }
>+    }
>+    if (jj_3R_17()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_27() {
>+    if (jj_3R_31()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_35() {
>+    if (jj_scan_token(DOT)) return true;
>     Token xsp;
>     xsp = jj_scanpos;
>     if (jj_scan_token(47)) jj_scanpos = xsp;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_31() {
>+    Token xsp;
>     xsp = jj_scanpos;
>-    if (jj_3R_10()) jj_scanpos = xsp;
>+    if (jj_3R_35()) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_36()) return true;
>+    }
>     return false;
>   }
> 
>   final private boolean jj_3_2() {
>+    if (jj_scan_token(IDENTIFIER)) return true;
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(26)) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_10()) return true;
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_29() {
>+    if (jj_scan_token(LPAREN)) return true;
>+    if (jj_3R_33()) return true;
>+    if (jj_scan_token(RPAREN)) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_14() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(41)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(42)) return true;
>+    }
>+    if (jj_3R_13()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_39() {
>+    if (jj_scan_token(COMMA)) return true;
>+    if (jj_3R_33()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_15() {
>+    if (jj_3R_17()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_18()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_30() {
>+    if (jj_3R_34()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_28() {
>+    if (jj_3R_32()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_26() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_3R_28()) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_29()) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_30()) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(47)) return true;
>+    }
>+    }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_25() {
>+    if (jj_3R_26()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_27()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_16() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(18)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(19)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(24)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(25)) return true;
>+    }
>+    }
>+    }
>+    if (jj_3R_15()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_24() {
>+    if (jj_3R_25()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_13() {
>+    if (jj_3R_15()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_16()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_12() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(43)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(44)) return true;
>+    }
>+    if (jj_3R_11()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_23() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(39)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(40)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(33)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(45)) return true;
>+    }
>+    }
>+    }
>+    if (jj_3R_21()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_20() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(32)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(33)) return true;
>+    }
>+    if (jj_3R_19()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_21() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_3R_23()) {
>+    jj_scanpos = xsp;
>+    if (jj_3R_24()) return true;
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_10() {
>+    if (jj_scan_token(COLON)) return true;
>+    if (jj_scan_token(IDENTIFIER)) return true;
>+    if (jj_scan_token(LPAREN)) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_22() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(34)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(35)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(36)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(37)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(38)) return true;
>+    }
>+    }
>+    }
>+    }
>+    if (jj_3R_21()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_40() {
>     if (jj_3R_9()) return true;
>+    if (jj_scan_token(COND)) return true;
>+    if (jj_3R_33()) return true;
>+    if (jj_scan_token(COLON)) return true;
>+    if (jj_3R_33()) return true;
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_32() {
>+    Token xsp;
>+    xsp = jj_scanpos;
>+    if (jj_scan_token(10)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(11)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(5)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(6)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(8)) {
>+    jj_scanpos = xsp;
>+    if (jj_scan_token(12)) return true;
>+    }
>+    }
>+    }
>+    }
>+    }
>+    return false;
>+  }
>+
>+  final private boolean jj_3R_11() {
>+    if (jj_3R_13()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_14()) { jj_scanpos = xsp; break; }
>+    }
>     return false;
>   }
> 
>   final private boolean jj_3_1() {
>+    if (jj_3R_9()) return true;
>     if (jj_scan_token(COND)) return true;
>     return false;
>   }
> 
>+  final private boolean jj_3R_19() {
>+    if (jj_3R_21()) return true;
>+    Token xsp;
>+    while (true) {
>+      xsp = jj_scanpos;
>+      if (jj_3R_22()) { jj_scanpos = xsp; break; }
>+    }
>+    return false;
>+  }
>+
>   public JSPELParserTokenManager token_source;
>   SimpleCharStream jj_input_stream;
>   public Token token, jj_nt;
>@@ -891,7 +1227,7 @@
>   public boolean lookingAhead = false;
> //  private boolean jj_semLA;
>   private int jj_gen;
>-  final private int[] jj_la1 = new int[24];
>+  final private int[] jj_la1 = new int[22];
>   static private int[] jj_la1_0;
>   static private int[] jj_la1_1;
>   static {
>@@ -899,12 +1235,12 @@
>       jj_la1_1();
>    }
>    private static void jj_la1_0() {
>-      jj_la1_0 = new int[] {0x4001d60,0x0,0x0,0x0,0x0,0x30c0000,0x30c0000,0xf3c000,0xf3c000,0x0,0x0,0x0,0x0,0x0,0x4001d60,0x40002000,0x4001d60,0x0,0x0,0x40002000,0x0,0x10000000,0x4000000,0x1d60,};
>+      jj_la1_0 = new int[] {0x4001d60,0x0,0x0,0x0,0x0,0x30c0000,0x30c0000,0xf3c000,0xf3c000,0x0,0x0,0x0,0x0,0x0,0x4001d60,0x40002000,0x4001d60,0x0,0x0,0x40002000,0x10000000,0x1d60,};
>    }
>    private static void jj_la1_1() {
>-      jj_la1_1 = new int[] {0xa182,0x1800,0x1800,0x600,0x600,0x0,0x0,0x0,0x0,0x3,0x3,0x7c,0x7c,0x2182,0xa182,0x0,0x0,0x8000,0x8000,0x0,0x8000,0x0,0x0,0x0,};
>+      jj_la1_1 = new int[] {0xa182,0x1800,0x1800,0x600,0x600,0x0,0x0,0x0,0x0,0x3,0x3,0x7c,0x7c,0x2182,0xa182,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,};
>    }
>-  final private JJCalls[] jj_2_rtns = new JJCalls[2];
>+  final private JJCalls[] jj_2_rtns = new JJCalls[3];
>   private boolean jj_rescan = false;
>   private int jj_gc = 0;
> 
>@@ -914,7 +1250,7 @@
>     token = new Token();
>     jj_ntk = -1;
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -925,7 +1261,7 @@
>     jj_ntk = -1;
>     jjtree.reset();
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -935,7 +1271,7 @@
>     token = new Token();
>     jj_ntk = -1;
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -946,7 +1282,7 @@
>     jj_ntk = -1;
>     jjtree.reset();
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -955,7 +1291,7 @@
>     token = new Token();
>     jj_ntk = -1;
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -965,7 +1301,7 @@
>     jj_ntk = -1;
>     jjtree.reset();
>     jj_gen = 0;
>-    for (int i = 0; i < 24; i++) jj_la1[i] = -1;
>+    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
>     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
>   }
> 
>@@ -1086,7 +1422,7 @@
>       la1tokens[jj_kind] = true;
>       jj_kind = -1;
>     }
>-    for (int i = 0; i < 24; i++) {
>+    for (int i = 0; i < 22; i++) {
>       if (jj_la1[i] == jj_gen) {
>         for (int j = 0; j < 32; j++) {
>           if ((jj_la1_0[i] & (1<<j)) != 0) {
>@@ -1123,7 +1459,7 @@
> 
>   final private void jj_rescan_token() {
>     jj_rescan = true;
>-    for (int i = 0; i < 2; i++) {
>+    for (int i = 0; i < 3; i++) {
>       JJCalls p = jj_2_rtns[i];
>       do {
>         if (p.gen > jj_gen) {
>@@ -1131,6 +1467,7 @@
>           switch (i) {
>             case 0: jj_3_1(); break;
>             case 1: jj_3_2(); break;
>+            case 2: jj_3_3(); break;
>           }
>         }
>         p = p.next;
>Index: src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jj
>===================================================================
>RCS file: /cvsroot/webtools/sourceediting/plugins/org.eclipse.jst.jsp.core/src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jj,v
>retrieving revision 1.5
>diff -u -r1.5 JSPEL.jj
>--- src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jj	24 Aug 2005 21:46:48 -0000	1.5
>+++ src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jj	9 Mar 2008 21:34:19 -0000
>@@ -1,675 +1,676 @@
>-*******************************************************************************
>- * Copyright (c) 2005 BEA Systems and others.
>- * All rights reserved. This program and the accompanying materials
>- * are made available under the terms of the Eclipse Public License v1.0
>- * which accompanies this distribution, and is available at
>- * http://www.eclipse.org/legal/epl-v10.html
>- * 
>- * Contributors:
>- *     BEA Systems - initial implementation
>- *     
>- *******************************************************************************/
>-/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. JSPEL.jj */
>-/*@egen*//* I know that haing some of these options on one line is rude but 
>- * if we don't do that the line number reported from javacc are off
>- * which, trust me, is far more annoying.  --tcarroll@bea.com
>- */
>-options {
>-  JAVA_UNICODE_ESCAPE = false;
>-  UNICODE_INPUT = true;
>-  STATIC = false;
>-  OPTIMIZE_TOKEN_MANAGER = true;                                                                                                                     
>-}
>-
>-PARSER_BEGIN(JSPELParser)
>-
>-package org.eclipse.jst.jsp.core.internal.java.jspel;
>-
>-public class JSPELParser/*@bgen(jjtree)*/implements JSPELParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
>-  protected JJTJSPELParserState jjtree = new JJTJSPELParserState();
>-
>-/*@egen*/
>-  
>-  void jjtreeOpenNodeScope(Node n)
>-  {
>-          ((SimpleNode)n).setFirstToken(getToken(1));
>-  }
>-
>-  void jjtreeCloseNodeScope(Node n)
>-  {
>-    ((SimpleNode)n).setLastToken(getToken(0));
>-  }
>-  
>-  public static JSPELParser createParser(java.lang.String input) {
>-          java.io.StringReader reader = new java.io.StringReader(input);
>-          return new JSPELParser(reader);
>-  }
>-  
>-  public void ReInit(java.lang.String input) {
>-           java.io.StringReader reader = new java.io.StringReader(input);
>-           ReInit(reader);
>-  }
>-  
>-}
>-
>-PARSER_END(JSPELParser)
>-
>-SKIP :
>-{
>-  " "
>-| "\t"
>-| "\n"
>-| "\r"
>-}
>-
>-TOKEN :
>-{
>-/* Literals */
>-  < INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
>-|
>-  < FLOATING_POINT_LITERAL:
>-        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
>-      | "." (["0"-"9"])+ (<EXPONENT>)?
>-      | (["0"-"9"])+ <EXPONENT>
>-  >
>-|
>-  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
>-|
>-  < STRING_LITERAL:
>-      ("\"" ((~["\"","\\"]) | ("\\" ( ["\\","\""] )))* "\"") |
>-      ("\'" ((~["\'","\\"]) | ("\\" ( ["\\","\'"] )))* "\'")
>-  >
>-|
>-  < BADLY_ESCAPED_STRING_LITERAL:
>-      ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] ))) |
>-      ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
>-  >
>-
>-/* Reserved Words and Symbols */
>-| < TRUE: "true" >
>-| < FALSE: "false" >
>-| < NULL: "null" >
>-| < DOT: "." >
>-| < GT1: ">" >
>-| < GT2: "gt" >
>-| < LT1: "<" >
>-| < LT2: "lt" >
>-| < EQ1: "==" >
>-| < EQ2: "eq" >
>-| < LE1: "<=" >
>-| < LE2: "le" >
>-| < GE1: ">=" >
>-| < GE2: "ge" >
>-| < NEQ1: "!=" >
>-| < NEQ2: "ne" >
>-| < LPAREN: "(" >
>-| < RPAREN: ")" >
>-| < COMMA: "," >
>-| < COLON: ":" >
>-| < LBRACKET: "[" >
>-| < RBRACKET: "]" >
>-| < PLUS: "+" >
>-| < MINUS: "-" >
>-| < MULTIPLY: "*" >
>-| < DIVIDE1: "/" >
>-| < DIVIDE2: "div" >
>-| < MODULUS1: "%" >
>-| < MODULUS2: "mod" >
>-| < NOT1: "not" >
>-| < NOT2: "!" >
>-| < AND1: "and" >
>-| < AND2: "&&" >
>-| < OR1: "or" >
>-| < OR2: "||" >
>-| < EMPTY: "empty" >
>-| < COND: "?" >
>-
>-/* Identifiers */
>-
>-| < IDENTIFIER: (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
>-| < #IMPL_OBJ_START: "#" >
>-|
>-  < #LETTER:
>-      [
>-       "$",
>-       "A"-"Z",
>-       "_",
>-       "a"-"z",
>-       "\u00c0"-"\u00d6",
>-       "\u00d8"-"\u00f6",
>-       "\u00f8"-"\u00ff",
>-       "\u0100"-"\u1fff",
>-       "\u3040"-"\u318f",
>-       "\u3300"-"\u337f",
>-       "\u3400"-"\u3d2d",
>-       "\u4e00"-"\u9fff",
>-       "\uf900"-"\ufaff"
>-      ]
>-  >
>-|
>-  < #DIGIT:
>-      [
>-       "0"-"9",
>-       "\u0660"-"\u0669",
>-       "\u06f0"-"\u06f9",
>-       "\u0966"-"\u096f",
>-       "\u09e6"-"\u09ef",
>-       "\u0a66"-"\u0a6f",
>-       "\u0ae6"-"\u0aef",
>-       "\u0b66"-"\u0b6f",
>-       "\u0be7"-"\u0bef",
>-       "\u0c66"-"\u0c6f",
>-       "\u0ce6"-"\u0cef",
>-       "\u0d66"-"\u0d6f",
>-       "\u0e50"-"\u0e59",
>-       "\u0ed0"-"\u0ed9",
>-       "\u1040"-"\u1049"
>-      ]
>-  >
>-}
>-
>-ASTExpression Expression() : {/*@bgen(jjtree) Expression */
>-  ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) Expression */
>-        try {
>-/*@egen*/
>-        (LOOKAHEAD("?") ChoiceExpression() | OrExpression())/*@bgen(jjtree)*/
>-                                                             {
>-                                                               jjtree.closeNodeScope(jjtn000, true);
>-                                                               jjtc000 = false;
>-                                                               jjtreeCloseNodeScope(jjtn000);
>-                                                             }
>-/*@egen*/ { return jjtn000; }/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void OrExpression()                   : 
>-{/*@bgen(jjtree) #OrExpression(> 1) */
>-        ASTOrExpression jjtn000 = new ASTOrExpression(JJTOREXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #OrExpression(> 1) */
>-        try {
>-/*@egen*/
>-        AndExpression() ((t = <OR1> | t = <OR2>) { jjtn000.addOperatorToken(t); }
>-        AndExpression())*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void AndExpression()                    : 
>-{/*@bgen(jjtree) #AndExpression(> 1) */
>-        ASTAndExpression jjtn000 = new ASTAndExpression(JJTANDEXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #AndExpression(> 1) */
>-        try {
>-/*@egen*/
>-        EqualityExpression() ((t = <AND1> | t = <AND2>) { jjtn000.addOperatorToken(t); }
>-        EqualityExpression())*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/        
>-}
>-
>-void EqualityExpression()                         : 
>-{/*@bgen(jjtree) #EqualityExpression(> 1) */
>-        ASTEqualityExpression jjtn000 = new ASTEqualityExpression(JJTEQUALITYEXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #EqualityExpression(> 1) */
>-        try {
>-/*@egen*/
>-        RelationalExpression() 
>-        ((t = <EQ1> | t = <EQ2> | t = <NEQ1> | t = <NEQ2>) { jjtn000.addOperatorToken(t); }
>-        RelationalExpression())*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void RelationalExpression()                           :
>-{/*@bgen(jjtree) #RelationalExpression(> 1) */
>-        ASTRelationalExpression jjtn000 = new ASTRelationalExpression(JJTRELATIONALEXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #RelationalExpression(> 1) */
>-        try {
>-/*@egen*/
>-        AddExpression() 
>-        (
>-                (t = <LT1> | t = <LT2> | t = <GT1> | t = <GT2> | t = <GE1> | t = <GE2> | t = <LE1> | t = <LE2>)  { jjtn000.addOperatorToken(t); }
>-                AddExpression()
>-        )*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void AddExpression()                    : 
>-{/*@bgen(jjtree) #AddExpression(> 1) */
>-        ASTAddExpression jjtn000 = new ASTAddExpression(JJTADDEXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #AddExpression(> 1) */
>-        try {
>-/*@egen*/
>-        MultiplyExpression() ((t = <PLUS> | t = <MINUS>) { jjtn000.addOperatorToken(t); }
>-        MultiplyExpression())*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void MultiplyExpression()                         : 
>-{/*@bgen(jjtree) #MultiplyExpression(> 1) */
>-        ASTMultiplyExpression jjtn000 = new ASTMultiplyExpression(JJTMULTIPLYEXPRESSION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t;
>-}
>-{/*@bgen(jjtree) #MultiplyExpression(> 1) */
>-        try {
>-/*@egen*/
>-        UnaryExpression() (
>-                ( t = <MULTIPLY> | t = <DIVIDE1> | t = <DIVIDE2> | t = <MODULUS1> | t = <MODULUS2>) { jjtn000.addOperatorToken(t); }
>-                UnaryExpression()        
>-        )*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void ChoiceExpression() : {/*@bgen(jjtree) ChoiceExpression */
>-  ASTChoiceExpression jjtn000 = new ASTChoiceExpression(JJTCHOICEEXPRESSION);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) ChoiceExpression */
>-        try {
>-/*@egen*/
>-        OrExpression() <COND> OrExpression() <COLON> OrExpression()/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void UnaryExpression() : {/*@bgen(jjtree) UnaryExpression */
>-  ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) UnaryExpression */
>-        try {
>-/*@egen*/
>-        ((<NOT1> | <NOT2> | <MINUS> | <EMPTY>) UnaryExpression())
>-        | Value()/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-        
>-}
>-
>-void Value() : {/*@bgen(jjtree) Value */
>-  ASTValue jjtn000 = new ASTValue(JJTVALUE);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) Value */
>-        try {
>-/*@egen*/
>-        ValuePrefix() (ValueSuffix())*/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void ValuePrefix() : {/*@bgen(jjtree) ValuePrefix */
>-  ASTValuePrefix jjtn000 = new ASTValuePrefix(JJTVALUEPREFIX);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) ValuePrefix */
>-    try {
>-/*@egen*/
>-    Literal() | (<LPAREN> Expression() <RPAREN>) | LOOKAHEAD(3) FunctionInvocation() | <IDENTIFIER>/*@bgen(jjtree)*/
>-    } catch (Throwable jjte000) {
>-      if (jjtc000) {
>-        jjtree.clearNodeScope(jjtn000);
>-        jjtc000 = false;
>-      } else {
>-        jjtree.popNode();
>-      }
>-      if (jjte000 instanceof RuntimeException) {
>-        throw (RuntimeException)jjte000;
>-      }
>-      if (jjte000 instanceof ParseException) {
>-        throw (ParseException)jjte000;
>-      }
>-      throw (Error)jjte000;
>-    } finally {
>-      if (jjtc000) {
>-        jjtree.closeNodeScope(jjtn000, true);
>-        jjtreeCloseNodeScope(jjtn000);
>-      }
>-    }
>-/*@egen*/ 
>-}
>-
>-void ValueSuffix() : 
>-{/*@bgen(jjtree) ValueSuffix */
>-        ASTValueSuffix jjtn000 = new ASTValueSuffix(JJTVALUESUFFIX);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token t = null;
>-}
>-{/*@bgen(jjtree) ValueSuffix */
>-        try {
>-/*@egen*/
>-        (<DOT> (t = <IDENTIFIER>)?)/*@bgen(jjtree)*/
>-                                    {
>-                                      jjtree.closeNodeScope(jjtn000, true);
>-                                      jjtc000 = false;
>-                                      jjtreeCloseNodeScope(jjtn000);
>-                                    }
>-/*@egen*/ { jjtn000.setPropertyNameToken(t); }
>-        | (<LBRACKET> Expression() <RBRACKET>)/*@bgen(jjtree)*/
>-        } catch (Throwable jjte000) {
>-          if (jjtc000) {
>-            jjtree.clearNodeScope(jjtn000);
>-            jjtc000 = false;
>-          } else {
>-            jjtree.popNode();
>-          }
>-          if (jjte000 instanceof RuntimeException) {
>-            throw (RuntimeException)jjte000;
>-          }
>-          if (jjte000 instanceof ParseException) {
>-            throw (ParseException)jjte000;
>-          }
>-          throw (Error)jjte000;
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>-
>-void FunctionInvocation() : 
>-{/*@bgen(jjtree) FunctionInvocation */
>-        ASTFunctionInvocation jjtn000 = new ASTFunctionInvocation(JJTFUNCTIONINVOCATION);
>-        boolean jjtc000 = true;
>-        jjtree.openNodeScope(jjtn000);
>-        jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/
>-        Token prefix = null, name = null;
>-}
>-{/*@bgen(jjtree) FunctionInvocation */
>-    try {
>-/*@egen*/
>-    (prefix = <IDENTIFIER> <COLON>) { jjtn000.setFullFunctionName(prefix.image + ":"); }
>-        (name = <IDENTIFIER>)? {
>-            if(null != prefix && null != name)
>-                    jjtn000.setFullFunctionName(prefix.image + ":" + (null == name ? "" : name.image));
>-            else if(null != name)
>-                    jjtn000.setFullFunctionName(name.image);
>-        }
>-        (<LPAREN> Expression() (<COMMA> Expression())* try  { (<RPAREN>) } catch (Exception e) {} )?/*@bgen(jjtree)*/
>-    } catch (Throwable jjte000) {
>-      if (jjtc000) {
>-        jjtree.clearNodeScope(jjtn000);
>-        jjtc000 = false;
>-      } else {
>-        jjtree.popNode();
>-      }
>-      if (jjte000 instanceof RuntimeException) {
>-        throw (RuntimeException)jjte000;
>-      }
>-      if (jjte000 instanceof ParseException) {
>-        throw (ParseException)jjte000;
>-      }
>-      throw (Error)jjte000;
>-    } finally {
>-      if (jjtc000) {
>-        jjtree.closeNodeScope(jjtn000, true);
>-        jjtreeCloseNodeScope(jjtn000);
>-      }
>-    }
>-/*@egen*/
>-}
>-
>-void Literal() : {/*@bgen(jjtree) Literal */
>-  ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
>-  boolean jjtc000 = true;
>-  jjtree.openNodeScope(jjtn000);
>-  jjtreeOpenNodeScope(jjtn000);
>-/*@egen*/}
>-{/*@bgen(jjtree) Literal */
>-        try {
>-/*@egen*/
>-        <TRUE> | <FALSE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <STRING_LITERAL> | <NULL>/*@bgen(jjtree)*/
>-        } finally {
>-          if (jjtc000) {
>-            jjtree.closeNodeScope(jjtn000, true);
>-            jjtreeCloseNodeScope(jjtn000);
>-          }
>-        }
>-/*@egen*/
>-}
>+/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. JSPEL.jj */
>+/*@egen*//*******************************************************************************
>+ * Copyright (c) 2005 BEA Systems and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ * 
>+ * Contributors:
>+ *     BEA Systems - initial implementation
>+ *     
>+ *******************************************************************************/
>+/* I know that having some of these options on one line is rude but 
>+ * if we don't do that the line number reported from javacc are off
>+ * which, trust me, is far more annoying.  --tcarroll@bea.com
>+ */
>+options {
>+  JAVA_UNICODE_ESCAPE = false;
>+  UNICODE_INPUT = true;
>+  STATIC = false;
>+  OPTIMIZE_TOKEN_MANAGER = true;                                                                                                                     
>+}
>+
>+PARSER_BEGIN(JSPELParser)
>+
>+package org.eclipse.jst.jsp.core.internal.java.jspel;
>+
>+public class JSPELParser/*@bgen(jjtree)*/implements JSPELParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
>+  protected JJTJSPELParserState jjtree = new JJTJSPELParserState();
>+
>+/*@egen*/
>+  
>+  void jjtreeOpenNodeScope(Node n)
>+  {
>+          ((SimpleNode)n).setFirstToken(getToken(1));
>+  }
>+
>+  void jjtreeCloseNodeScope(Node n)
>+  {
>+    ((SimpleNode)n).setLastToken(getToken(0));
>+  }
>+  
>+  public static JSPELParser createParser(java.lang.String input) {
>+          java.io.StringReader reader = new java.io.StringReader(input);
>+          return new JSPELParser(reader);
>+  }
>+  
>+  public void ReInit(java.lang.String input) {
>+           java.io.StringReader reader = new java.io.StringReader(input);
>+           ReInit(reader);
>+  }
>+  
>+}
>+
>+PARSER_END(JSPELParser)
>+
>+SKIP :
>+{
>+  " "
>+| "\t"
>+| "\n"
>+| "\r"
>+}
>+
>+TOKEN :
>+{
>+/* Literals */
>+  < INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
>+|
>+  < FLOATING_POINT_LITERAL:
>+        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
>+      | "." (["0"-"9"])+ (<EXPONENT>)?
>+      | (["0"-"9"])+ <EXPONENT>
>+  >
>+|
>+  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
>+|
>+  < STRING_LITERAL:
>+      ("\"" ((~["\"","\\"]) | ("\\" ( ["\\","\""] )))* "\"") |
>+      ("\'" ((~["\'","\\"]) | ("\\" ( ["\\","\'"] )))* "\'")
>+  >
>+|
>+  < BADLY_ESCAPED_STRING_LITERAL:
>+      ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] ))) |
>+      ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
>+  >
>+
>+/* Reserved Words and Symbols */
>+| < TRUE: "true" >
>+| < FALSE: "false" >
>+| < NULL: "null" >
>+| < DOT: "." >
>+| < GT1: ">" >
>+| < GT2: "gt" >
>+| < LT1: "<" >
>+| < LT2: "lt" >
>+| < EQ1: "==" >
>+| < EQ2: "eq" >
>+| < LE1: "<=" >
>+| < LE2: "le" >
>+| < GE1: ">=" >
>+| < GE2: "ge" >
>+| < NEQ1: "!=" >
>+| < NEQ2: "ne" >
>+| < LPAREN: "(" >
>+| < RPAREN: ")" >
>+| < COMMA: "," >
>+| < COLON: ":" >
>+| < LBRACKET: "[" >
>+| < RBRACKET: "]" >
>+| < PLUS: "+" >
>+| < MINUS: "-" >
>+| < MULTIPLY: "*" >
>+| < DIVIDE1: "/" >
>+| < DIVIDE2: "div" >
>+| < MODULUS1: "%" >
>+| < MODULUS2: "mod" >
>+| < NOT1: "not" >
>+| < NOT2: "!" >
>+| < AND1: "and" >
>+| < AND2: "&&" >
>+| < OR1: "or" >
>+| < OR2: "||" >
>+| < EMPTY: "empty" >
>+| < COND: "?" >
>+
>+/* Identifiers */
>+
>+| < IDENTIFIER: (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
>+| < #IMPL_OBJ_START: "#" >
>+|
>+  < #LETTER:
>+      [
>+       "$",
>+       "A"-"Z",
>+       "_",
>+       "a"-"z",
>+       "\u00c0"-"\u00d6",
>+       "\u00d8"-"\u00f6",
>+       "\u00f8"-"\u00ff",
>+       "\u0100"-"\u1fff",
>+       "\u3040"-"\u318f",
>+       "\u3300"-"\u337f",
>+       "\u3400"-"\u3d2d",
>+       "\u4e00"-"\u9fff",
>+       "\uf900"-"\ufaff"
>+      ]
>+  >
>+|
>+  < #DIGIT:
>+      [
>+       "0"-"9",
>+       "\u0660"-"\u0669",
>+       "\u06f0"-"\u06f9",
>+       "\u0966"-"\u096f",
>+       "\u09e6"-"\u09ef",
>+       "\u0a66"-"\u0a6f",
>+       "\u0ae6"-"\u0aef",
>+       "\u0b66"-"\u0b6f",
>+       "\u0be7"-"\u0bef",
>+       "\u0c66"-"\u0c6f",
>+       "\u0ce6"-"\u0cef",
>+       "\u0d66"-"\u0d6f",
>+       "\u0e50"-"\u0e59",
>+       "\u0ed0"-"\u0ed9",
>+       "\u1040"-"\u1049"
>+      ]
>+  >
>+}
>+
>+ASTExpression Expression() : {/*@bgen(jjtree) Expression */
>+  ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) Expression */
>+        try {
>+/*@egen*/
>+        (LOOKAHEAD(OrExpression() <COND>) ChoiceExpression() | OrExpression())/*@bgen(jjtree)*/
>+                                                                               {
>+                                                                                 jjtree.closeNodeScope(jjtn000, true);
>+                                                                                 jjtc000 = false;
>+                                                                                 jjtreeCloseNodeScope(jjtn000);
>+                                                                               }
>+/*@egen*/ { return jjtn000; }/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void OrExpression()                   : 
>+{/*@bgen(jjtree) #OrExpression(> 1) */
>+        ASTOrExpression jjtn000 = new ASTOrExpression(JJTOREXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #OrExpression(> 1) */
>+        try {
>+/*@egen*/
>+        AndExpression() ((t = <OR1> | t = <OR2>) { jjtn000.addOperatorToken(t); }
>+        AndExpression())*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void AndExpression()                    : 
>+{/*@bgen(jjtree) #AndExpression(> 1) */
>+        ASTAndExpression jjtn000 = new ASTAndExpression(JJTANDEXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #AndExpression(> 1) */
>+        try {
>+/*@egen*/
>+        EqualityExpression() ((t = <AND1> | t = <AND2>) { jjtn000.addOperatorToken(t); }
>+        EqualityExpression())*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/        
>+}
>+
>+void EqualityExpression()                         : 
>+{/*@bgen(jjtree) #EqualityExpression(> 1) */
>+        ASTEqualityExpression jjtn000 = new ASTEqualityExpression(JJTEQUALITYEXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #EqualityExpression(> 1) */
>+        try {
>+/*@egen*/
>+        RelationalExpression() 
>+        ((t = <EQ1> | t = <EQ2> | t = <NEQ1> | t = <NEQ2>) { jjtn000.addOperatorToken(t); }
>+        RelationalExpression())*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void RelationalExpression()                           :
>+{/*@bgen(jjtree) #RelationalExpression(> 1) */
>+        ASTRelationalExpression jjtn000 = new ASTRelationalExpression(JJTRELATIONALEXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #RelationalExpression(> 1) */
>+        try {
>+/*@egen*/
>+        AddExpression() 
>+        (
>+                (t = <LT1> | t = <LT2> | t = <GT1> | t = <GT2> | t = <GE1> | t = <GE2> | t = <LE1> | t = <LE2>)  { jjtn000.addOperatorToken(t); }
>+                AddExpression()
>+        )*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void AddExpression()                    : 
>+{/*@bgen(jjtree) #AddExpression(> 1) */
>+        ASTAddExpression jjtn000 = new ASTAddExpression(JJTADDEXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #AddExpression(> 1) */
>+        try {
>+/*@egen*/
>+        MultiplyExpression() ((t = <PLUS> | t = <MINUS>) { jjtn000.addOperatorToken(t); }
>+        MultiplyExpression())*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void MultiplyExpression()                         : 
>+{/*@bgen(jjtree) #MultiplyExpression(> 1) */
>+        ASTMultiplyExpression jjtn000 = new ASTMultiplyExpression(JJTMULTIPLYEXPRESSION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t;
>+}
>+{/*@bgen(jjtree) #MultiplyExpression(> 1) */
>+        try {
>+/*@egen*/
>+        UnaryExpression() (
>+                ( t = <MULTIPLY> | t = <DIVIDE1> | t = <DIVIDE2> | t = <MODULUS1> | t = <MODULUS2>) { jjtn000.addOperatorToken(t); }
>+                UnaryExpression()        
>+        )*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void ChoiceExpression() : {/*@bgen(jjtree) ChoiceExpression */
>+  ASTChoiceExpression jjtn000 = new ASTChoiceExpression(JJTCHOICEEXPRESSION);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) ChoiceExpression */
>+        try {
>+/*@egen*/
>+        OrExpression() <COND> Expression() <COLON> Expression()/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void UnaryExpression() : {/*@bgen(jjtree) UnaryExpression */
>+  ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) UnaryExpression */
>+        try {
>+/*@egen*/
>+        ((<NOT1> | <NOT2> | <MINUS> | <EMPTY>) UnaryExpression())
>+        | Value()/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+        
>+}
>+
>+void Value() : {/*@bgen(jjtree) Value */
>+  ASTValue jjtn000 = new ASTValue(JJTVALUE);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) Value */
>+        try {
>+/*@egen*/
>+        ValuePrefix() (ValueSuffix())*/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void ValuePrefix() : {/*@bgen(jjtree) ValuePrefix */
>+  ASTValuePrefix jjtn000 = new ASTValuePrefix(JJTVALUEPREFIX);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) ValuePrefix */
>+    try {
>+/*@egen*/
>+    Literal() | (<LPAREN> Expression() <RPAREN>)
>+    | LOOKAHEAD(<IDENTIFIER> (<LPAREN> | <COLON> <IDENTIFIER> <LPAREN>)) FunctionInvocation() | <IDENTIFIER>/*@bgen(jjtree)*/
>+    } catch (Throwable jjte000) {
>+      if (jjtc000) {
>+        jjtree.clearNodeScope(jjtn000);
>+        jjtc000 = false;
>+      } else {
>+        jjtree.popNode();
>+      }
>+      if (jjte000 instanceof RuntimeException) {
>+        throw (RuntimeException)jjte000;
>+      }
>+      if (jjte000 instanceof ParseException) {
>+        throw (ParseException)jjte000;
>+      }
>+      throw (Error)jjte000;
>+    } finally {
>+      if (jjtc000) {
>+        jjtree.closeNodeScope(jjtn000, true);
>+        jjtreeCloseNodeScope(jjtn000);
>+      }
>+    }
>+/*@egen*/ 
>+}
>+
>+void ValueSuffix() : 
>+{/*@bgen(jjtree) ValueSuffix */
>+        ASTValueSuffix jjtn000 = new ASTValueSuffix(JJTVALUESUFFIX);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token t = null;
>+}
>+{/*@bgen(jjtree) ValueSuffix */
>+        try {
>+/*@egen*/
>+        (<DOT> (t = <IDENTIFIER>)?)/*@bgen(jjtree)*/
>+                                    {
>+                                      jjtree.closeNodeScope(jjtn000, true);
>+                                      jjtc000 = false;
>+                                      jjtreeCloseNodeScope(jjtn000);
>+                                    }
>+/*@egen*/ { jjtn000.setPropertyNameToken(t); }
>+        | (<LBRACKET> Expression() <RBRACKET>)/*@bgen(jjtree)*/
>+        } catch (Throwable jjte000) {
>+          if (jjtc000) {
>+            jjtree.clearNodeScope(jjtn000);
>+            jjtc000 = false;
>+          } else {
>+            jjtree.popNode();
>+          }
>+          if (jjte000 instanceof RuntimeException) {
>+            throw (RuntimeException)jjte000;
>+          }
>+          if (jjte000 instanceof ParseException) {
>+            throw (ParseException)jjte000;
>+          }
>+          throw (Error)jjte000;
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>+
>+void FunctionInvocation() : 
>+{/*@bgen(jjtree) FunctionInvocation */
>+        ASTFunctionInvocation jjtn000 = new ASTFunctionInvocation(JJTFUNCTIONINVOCATION);
>+        boolean jjtc000 = true;
>+        jjtree.openNodeScope(jjtn000);
>+        jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/
>+        Token prefix = null, name = null;
>+}
>+{/*@bgen(jjtree) FunctionInvocation */
>+    try {
>+/*@egen*/
>+    (LOOKAHEAD(2) prefix = <IDENTIFIER> <COLON>)?
>+        (name = <IDENTIFIER>) {
>+            if(null != prefix && null != name)
>+                    jjtn000.setFullFunctionName(prefix.image + ":" + (null == name ? "" : name.image));
>+            else if(null != name)
>+                    jjtn000.setFullFunctionName(name.image);
>+        }
>+        (<LPAREN> Expression() (<COMMA> Expression())* try  { (<RPAREN>) } catch (Exception e) {} )/*@bgen(jjtree)*/
>+    } catch (Throwable jjte000) {
>+      if (jjtc000) {
>+        jjtree.clearNodeScope(jjtn000);
>+        jjtc000 = false;
>+      } else {
>+        jjtree.popNode();
>+      }
>+      if (jjte000 instanceof RuntimeException) {
>+        throw (RuntimeException)jjte000;
>+      }
>+      if (jjte000 instanceof ParseException) {
>+        throw (ParseException)jjte000;
>+      }
>+      throw (Error)jjte000;
>+    } finally {
>+      if (jjtc000) {
>+        jjtree.closeNodeScope(jjtn000, true);
>+        jjtreeCloseNodeScope(jjtn000);
>+      }
>+    }
>+/*@egen*/
>+}
>+
>+void Literal() : {/*@bgen(jjtree) Literal */
>+  ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
>+  boolean jjtc000 = true;
>+  jjtree.openNodeScope(jjtn000);
>+  jjtreeOpenNodeScope(jjtn000);
>+/*@egen*/}
>+{/*@bgen(jjtree) Literal */
>+        try {
>+/*@egen*/
>+        <TRUE> | <FALSE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <STRING_LITERAL> | <NULL>/*@bgen(jjtree)*/
>+        } finally {
>+          if (jjtc000) {
>+            jjtree.closeNodeScope(jjtn000, true);
>+            jjtreeCloseNodeScope(jjtn000);
>+          }
>+        }
>+/*@egen*/
>+}
>Index: src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jjt
>===================================================================
>RCS file: /cvsroot/webtools/sourceediting/plugins/org.eclipse.jst.jsp.core/src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jjt,v
>retrieving revision 1.5
>diff -u -r1.5 JSPEL.jjt
>--- src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jjt	24 Aug 2005 21:46:48 -0000	1.5
>+++ src/org/eclipse/jst/jsp/core/internal/java/jspel/JSPEL.jjt	9 Mar 2008 21:34:19 -0000
>@@ -1,281 +1,282 @@
>-*******************************************************************************
>- * Copyright (c) 2005 BEA Systems and others.
>- * All rights reserved. This program and the accompanying materials
>- * are made available under the terms of the Eclipse Public License v1.0
>- * which accompanies this distribution, and is available at
>- * http://www.eclipse.org/legal/epl-v10.html
>- * 
>- * Contributors:
>- *     BEA Systems - initial implementation
>- *     
>- *******************************************************************************/
>-/* I know that having some of these options on one line is rude but 
>- * if we don't do that the line number reported from javacc are off
>- * which, trust me, is far more annoying.  --tcarroll@bea.com
>- */
>-options {
>-  JAVA_UNICODE_ESCAPE = false;
>-  UNICODE_INPUT = true;
>-  STATIC = false;
>-  OPTIMIZE_TOKEN_MANAGER = true; MULTI = true; VISITOR = true; NODE_PACKAGE = "org.eclipse.jst.jsp.core.internal.java.jspel"; NODE_SCOPE_HOOK = true;
>-}
>-
>-PARSER_BEGIN(JSPELParser)
>-
>-package org.eclipse.jst.jsp.core.internal.java.jspel;
>-
>-public class JSPELParser {
>-  
>-  void jjtreeOpenNodeScope(Node n)
>-  {
>-          ((SimpleNode)n).setFirstToken(getToken(1));
>-  }
>-
>-  void jjtreeCloseNodeScope(Node n)
>-  {
>-    ((SimpleNode)n).setLastToken(getToken(0));
>-  }
>-  
>-  public static JSPELParser createParser(java.lang.String input) {
>-          java.io.StringReader reader = new java.io.StringReader(input);
>-          return new JSPELParser(reader);
>-  }
>-  
>-  public void ReInit(java.lang.String input) {
>-           java.io.StringReader reader = new java.io.StringReader(input);
>-           ReInit(reader);
>-  }
>-  
>-}
>-
>-PARSER_END(JSPELParser)
>-
>-SKIP :
>-{
>-  " "
>-| "\t"
>-| "\n"
>-| "\r"
>-}
>-
>-TOKEN :
>-{
>-/* Literals */
>-  < INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
>-|
>-  < FLOATING_POINT_LITERAL:
>-        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
>-      | "." (["0"-"9"])+ (<EXPONENT>)?
>-      | (["0"-"9"])+ <EXPONENT>
>-  >
>-|
>-  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
>-|
>-  < STRING_LITERAL:
>-      ("\"" ((~["\"","\\"]) | ("\\" ( ["\\","\""] )))* "\"") |
>-      ("\'" ((~["\'","\\"]) | ("\\" ( ["\\","\'"] )))* "\'")
>-  >
>-|
>-  < BADLY_ESCAPED_STRING_LITERAL:
>-      ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] ))) |
>-      ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
>-  >
>-
>-/* Reserved Words and Symbols */
>-| < TRUE: "true" >
>-| < FALSE: "false" >
>-| < NULL: "null" >
>-| < DOT: "." >
>-| < GT1: ">" >
>-| < GT2: "gt" >
>-| < LT1: "<" >
>-| < LT2: "lt" >
>-| < EQ1: "==" >
>-| < EQ2: "eq" >
>-| < LE1: "<=" >
>-| < LE2: "le" >
>-| < GE1: ">=" >
>-| < GE2: "ge" >
>-| < NEQ1: "!=" >
>-| < NEQ2: "ne" >
>-| < LPAREN: "(" >
>-| < RPAREN: ")" >
>-| < COMMA: "," >
>-| < COLON: ":" >
>-| < LBRACKET: "[" >
>-| < RBRACKET: "]" >
>-| < PLUS: "+" >
>-| < MINUS: "-" >
>-| < MULTIPLY: "*" >
>-| < DIVIDE1: "/" >
>-| < DIVIDE2: "div" >
>-| < MODULUS1: "%" >
>-| < MODULUS2: "mod" >
>-| < NOT1: "not" >
>-| < NOT2: "!" >
>-| < AND1: "and" >
>-| < AND2: "&&" >
>-| < OR1: "or" >
>-| < OR2: "||" >
>-| < EMPTY: "empty" >
>-| < COND: "?" >
>-
>-/* Identifiers */
>-
>-| < IDENTIFIER: (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
>-| < #IMPL_OBJ_START: "#" >
>-|
>-  < #LETTER:
>-      [
>-       "\u0024",
>-       "\u0041"-"\u005a",
>-       "\u005f",
>-       "\u0061"-"\u007a",
>-       "\u00c0"-"\u00d6",
>-       "\u00d8"-"\u00f6",
>-       "\u00f8"-"\u00ff",
>-       "\u0100"-"\u1fff",
>-       "\u3040"-"\u318f",
>-       "\u3300"-"\u337f",
>-       "\u3400"-"\u3d2d",
>-       "\u4e00"-"\u9fff",
>-       "\uf900"-"\ufaff"
>-      ]
>-  >
>-|
>-  < #DIGIT:
>-      [
>-       "\u0030"-"\u0039",
>-       "\u0660"-"\u0669",
>-       "\u06f0"-"\u06f9",
>-       "\u0966"-"\u096f",
>-       "\u09e6"-"\u09ef",
>-       "\u0a66"-"\u0a6f",
>-       "\u0ae6"-"\u0aef",
>-       "\u0b66"-"\u0b6f",
>-       "\u0be7"-"\u0bef",
>-       "\u0c66"-"\u0c6f",
>-       "\u0ce6"-"\u0cef",
>-       "\u0d66"-"\u0d6f",
>-       "\u0e50"-"\u0e59",
>-       "\u0ed0"-"\u0ed9",
>-       "\u1040"-"\u1049"
>-      ]
>-  >
>-}
>-
>-ASTExpression Expression() : {}
>-{
>-        (LOOKAHEAD("?") ChoiceExpression() | OrExpression()) { return jjtThis; }
>-}
>-
>-void OrExpression() #OrExpression(>1) : 
>-{
>-        Token t;
>-}
>-{
>-        AndExpression() ((t = <OR1> | t = <OR2>) { jjtThis.addOperatorToken(t); }
>-        AndExpression())*
>-}
>-
>-void AndExpression() #AndExpression(>1) : 
>-{
>-        Token t;
>-}
>-{
>-        EqualityExpression() ((t = <AND1> | t = <AND2>) { jjtThis.addOperatorToken(t); }
>-        EqualityExpression())*        
>-}
>-
>-void EqualityExpression() #EqualityExpression(>1) : 
>-{
>-        Token t;
>-}
>-{
>-        RelationalExpression() 
>-        ((t = <EQ1> | t = <EQ2> | t = <NEQ1> | t = <NEQ2>) { jjtThis.addOperatorToken(t); }
>-        RelationalExpression())*
>-}
>-
>-void RelationalExpression() #RelationalExpression(>1) :
>-{
>-        Token t;
>-}
>-{
>-        AddExpression() 
>-        (
>-                (t = <LT1> | t = <LT2> | t = <GT1> | t = <GT2> | t = <GE1> | t = <GE2> | t = <LE1> | t = <LE2>)  { jjtThis.addOperatorToken(t); }
>-                AddExpression()
>-        )*
>-}
>-
>-void AddExpression() #AddExpression(>1) : 
>-{
>-        Token t;
>-}
>-{
>-        MultiplyExpression() ((t = <PLUS> | t = <MINUS>) { jjtThis.addOperatorToken(t); }
>-        MultiplyExpression())*
>-}
>-
>-void MultiplyExpression() #MultiplyExpression(>1) : 
>-{
>-        Token t;
>-}
>-{
>-        UnaryExpression() (
>-                ( t = <MULTIPLY> | t = <DIVIDE1> | t = <DIVIDE2> | t = <MODULUS1> | t = <MODULUS2>) { jjtThis.addOperatorToken(t); }
>-                UnaryExpression()        
>-        )*
>-}
>-
>-void ChoiceExpression() : {}
>-{
>-        OrExpression() <COND> OrExpression() <COLON> OrExpression()
>-}
>-
>-void UnaryExpression() : {}
>-{
>-        ((<NOT1> | <NOT2> | <MINUS> | <EMPTY>) UnaryExpression())
>-        | Value()
>-        
>-}
>-
>-void Value() : {}
>-{
>-        ValuePrefix() (ValueSuffix())*
>-}
>-
>-void ValuePrefix() : {}
>-{
>-    Literal() | (<LPAREN> Expression() <RPAREN>) | LOOKAHEAD(3) FunctionInvocation() | <IDENTIFIER> 
>-}
>-
>-void ValueSuffix() : 
>-{
>-        Token t = null;
>-}
>-{
>-        (<DOT> (t = <IDENTIFIER>)?) { jjtThis.setPropertyNameToken(t); }
>-        | (<LBRACKET> Expression() <RBRACKET>)
>-}
>-
>-void FunctionInvocation() : 
>-{
>-        Token prefix = null, name = null;
>-}
>-{
>-    (prefix = <IDENTIFIER> <COLON>) { jjtThis.setFullFunctionName(prefix.image + ":"); }
>-        (name = <IDENTIFIER>)? {
>-            if(null != prefix && null != name)
>-                    jjtThis.setFullFunctionName(prefix.image + ":" + (null == name ? "" : name.image));
>-            else if(null != name)
>-                    jjtThis.setFullFunctionName(name.image);
>-        }
>-        (<LPAREN> Expression() (<COMMA> Expression())* try  { (<RPAREN>) } catch (Exception e) {} )?
>-}
>-
>-void Literal() : {}
>-{
>-        <TRUE> | <FALSE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <STRING_LITERAL> | <NULL>
>-}
>+/*******************************************************************************
>+ * Copyright (c) 2005 BEA Systems and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ * 
>+ * Contributors:
>+ *     BEA Systems - initial implementation
>+ *     
>+ *******************************************************************************/
>+/* I know that having some of these options on one line is rude but 
>+ * if we don't do that the line number reported from javacc are off
>+ * which, trust me, is far more annoying.  --tcarroll@bea.com
>+ */
>+options {
>+  JAVA_UNICODE_ESCAPE = false;
>+  UNICODE_INPUT = true;
>+  STATIC = false;
>+  OPTIMIZE_TOKEN_MANAGER = true; MULTI = true; VISITOR = true; NODE_PACKAGE = "org.eclipse.jst.jsp.core.internal.java.jspel"; NODE_SCOPE_HOOK = true;
>+}
>+
>+PARSER_BEGIN(JSPELParser)
>+
>+package org.eclipse.jst.jsp.core.internal.java.jspel;
>+
>+public class JSPELParser {
>+  
>+  void jjtreeOpenNodeScope(Node n)
>+  {
>+          ((SimpleNode)n).setFirstToken(getToken(1));
>+  }
>+
>+  void jjtreeCloseNodeScope(Node n)
>+  {
>+    ((SimpleNode)n).setLastToken(getToken(0));
>+  }
>+  
>+  public static JSPELParser createParser(java.lang.String input) {
>+          java.io.StringReader reader = new java.io.StringReader(input);
>+          return new JSPELParser(reader);
>+  }
>+  
>+  public void ReInit(java.lang.String input) {
>+           java.io.StringReader reader = new java.io.StringReader(input);
>+           ReInit(reader);
>+  }
>+  
>+}
>+
>+PARSER_END(JSPELParser)
>+
>+SKIP :
>+{
>+  " "
>+| "\t"
>+| "\n"
>+| "\r"
>+}
>+
>+TOKEN :
>+{
>+/* Literals */
>+  < INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
>+|
>+  < FLOATING_POINT_LITERAL:
>+        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
>+      | "." (["0"-"9"])+ (<EXPONENT>)?
>+      | (["0"-"9"])+ <EXPONENT>
>+  >
>+|
>+  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
>+|
>+  < STRING_LITERAL:
>+      ("\"" ((~["\"","\\"]) | ("\\" ( ["\\","\""] )))* "\"") |
>+      ("\'" ((~["\'","\\"]) | ("\\" ( ["\\","\'"] )))* "\'")
>+  >
>+|
>+  < BADLY_ESCAPED_STRING_LITERAL:
>+      ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] ))) |
>+      ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
>+  >
>+
>+/* Reserved Words and Symbols */
>+| < TRUE: "true" >
>+| < FALSE: "false" >
>+| < NULL: "null" >
>+| < DOT: "." >
>+| < GT1: ">" >
>+| < GT2: "gt" >
>+| < LT1: "<" >
>+| < LT2: "lt" >
>+| < EQ1: "==" >
>+| < EQ2: "eq" >
>+| < LE1: "<=" >
>+| < LE2: "le" >
>+| < GE1: ">=" >
>+| < GE2: "ge" >
>+| < NEQ1: "!=" >
>+| < NEQ2: "ne" >
>+| < LPAREN: "(" >
>+| < RPAREN: ")" >
>+| < COMMA: "," >
>+| < COLON: ":" >
>+| < LBRACKET: "[" >
>+| < RBRACKET: "]" >
>+| < PLUS: "+" >
>+| < MINUS: "-" >
>+| < MULTIPLY: "*" >
>+| < DIVIDE1: "/" >
>+| < DIVIDE2: "div" >
>+| < MODULUS1: "%" >
>+| < MODULUS2: "mod" >
>+| < NOT1: "not" >
>+| < NOT2: "!" >
>+| < AND1: "and" >
>+| < AND2: "&&" >
>+| < OR1: "or" >
>+| < OR2: "||" >
>+| < EMPTY: "empty" >
>+| < COND: "?" >
>+
>+/* Identifiers */
>+
>+| < IDENTIFIER: (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
>+| < #IMPL_OBJ_START: "#" >
>+|
>+  < #LETTER:
>+      [
>+       "\u0024",
>+       "\u0041"-"\u005a",
>+       "\u005f",
>+       "\u0061"-"\u007a",
>+       "\u00c0"-"\u00d6",
>+       "\u00d8"-"\u00f6",
>+       "\u00f8"-"\u00ff",
>+       "\u0100"-"\u1fff",
>+       "\u3040"-"\u318f",
>+       "\u3300"-"\u337f",
>+       "\u3400"-"\u3d2d",
>+       "\u4e00"-"\u9fff",
>+       "\uf900"-"\ufaff"
>+      ]
>+  >
>+|
>+  < #DIGIT:
>+      [
>+       "\u0030"-"\u0039",
>+       "\u0660"-"\u0669",
>+       "\u06f0"-"\u06f9",
>+       "\u0966"-"\u096f",
>+       "\u09e6"-"\u09ef",
>+       "\u0a66"-"\u0a6f",
>+       "\u0ae6"-"\u0aef",
>+       "\u0b66"-"\u0b6f",
>+       "\u0be7"-"\u0bef",
>+       "\u0c66"-"\u0c6f",
>+       "\u0ce6"-"\u0cef",
>+       "\u0d66"-"\u0d6f",
>+       "\u0e50"-"\u0e59",
>+       "\u0ed0"-"\u0ed9",
>+       "\u1040"-"\u1049"
>+      ]
>+  >
>+}
>+
>+ASTExpression Expression() : {}
>+{
>+        (LOOKAHEAD(OrExpression() <COND>) ChoiceExpression() | OrExpression()) { return jjtThis; }
>+}
>+
>+void OrExpression() #OrExpression(>1) : 
>+{
>+        Token t;
>+}
>+{
>+        AndExpression() ((t = <OR1> | t = <OR2>) { jjtThis.addOperatorToken(t); }
>+        AndExpression())*
>+}
>+
>+void AndExpression() #AndExpression(>1) : 
>+{
>+        Token t;
>+}
>+{
>+        EqualityExpression() ((t = <AND1> | t = <AND2>) { jjtThis.addOperatorToken(t); }
>+        EqualityExpression())*        
>+}
>+
>+void EqualityExpression() #EqualityExpression(>1) : 
>+{
>+        Token t;
>+}
>+{
>+        RelationalExpression() 
>+        ((t = <EQ1> | t = <EQ2> | t = <NEQ1> | t = <NEQ2>) { jjtThis.addOperatorToken(t); }
>+        RelationalExpression())*
>+}
>+
>+void RelationalExpression() #RelationalExpression(>1) :
>+{
>+        Token t;
>+}
>+{
>+        AddExpression() 
>+        (
>+                (t = <LT1> | t = <LT2> | t = <GT1> | t = <GT2> | t = <GE1> | t = <GE2> | t = <LE1> | t = <LE2>)  { jjtThis.addOperatorToken(t); }
>+                AddExpression()
>+        )*
>+}
>+
>+void AddExpression() #AddExpression(>1) : 
>+{
>+        Token t;
>+}
>+{
>+        MultiplyExpression() ((t = <PLUS> | t = <MINUS>) { jjtThis.addOperatorToken(t); }
>+        MultiplyExpression())*
>+}
>+
>+void MultiplyExpression() #MultiplyExpression(>1) : 
>+{
>+        Token t;
>+}
>+{
>+        UnaryExpression() (
>+                ( t = <MULTIPLY> | t = <DIVIDE1> | t = <DIVIDE2> | t = <MODULUS1> | t = <MODULUS2>) { jjtThis.addOperatorToken(t); }
>+                UnaryExpression()        
>+        )*
>+}
>+
>+void ChoiceExpression() : {}
>+{
>+        OrExpression() <COND> Expression() <COLON> Expression()
>+}
>+
>+void UnaryExpression() : {}
>+{
>+        ((<NOT1> | <NOT2> | <MINUS> | <EMPTY>) UnaryExpression())
>+        | Value()
>+        
>+}
>+
>+void Value() : {}
>+{
>+        ValuePrefix() (ValueSuffix())*
>+}
>+
>+void ValuePrefix() : {}
>+{
>+    Literal() | (<LPAREN> Expression() <RPAREN>)
>+    | LOOKAHEAD(<IDENTIFIER> (<LPAREN> | <COLON> <IDENTIFIER> <LPAREN>)) FunctionInvocation() | <IDENTIFIER> 
>+}
>+
>+void ValueSuffix() : 
>+{
>+        Token t = null;
>+}
>+{
>+        (<DOT> (t = <IDENTIFIER>)?) { jjtThis.setPropertyNameToken(t); }
>+        | (<LBRACKET> Expression() <RBRACKET>)
>+}
>+
>+void FunctionInvocation() : 
>+{
>+        Token prefix = null, name = null;
>+}
>+{
>+    (LOOKAHEAD(2) prefix = <IDENTIFIER> <COLON>)?
>+        (name = <IDENTIFIER>) {
>+            if(null != prefix && null != name)
>+                    jjtThis.setFullFunctionName(prefix.image + ":" + (null == name ? "" : name.image));
>+            else if(null != name)
>+                    jjtThis.setFullFunctionName(name.image);
>+        }
>+        (<LPAREN> Expression() (<COMMA> Expression())* try  { (<RPAREN>) } catch (Exception e) {} )
>+}
>+
>+void Literal() : {}
>+{
>+        <TRUE> | <FALSE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <STRING_LITERAL> | <NULL>
>+}

Actions: View | Diff

Attachments on bug 221055: 91999