Attachment #20913 for bug #42565

View | Details | Raw Unified | Return to bug 42565
Collapse All | Expand All




/* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
package org.apache.el.parser;
import java.io.StringReader;
import javax.el.ELException;

public class ELParserTokenManager implements ELParserConstants
{
  public  java.io.PrintStream debugStream = System.out;
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
private final int jjStopStringLiteralDfa_0(int pos, long active0)
{
   switch (pos)
   {
      case 0:
         if ((active0 & 0x10L) != 0L)
            return 2;
         if ((active0 & 0x4L) != 0L)
         {
            jjmatchedKind = 1;
            return 4;
         }
         if ((active0 & 0x8L) != 0L)
         {
            jjmatchedKind = 1;
            return 6;
         }
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_0(int pos, long active0)
{
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
}
private final int jjStopAtPos(int pos, int kind)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   return pos + 1;
}
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) { return pos + 1; }
   return jjMoveNfa_0(state, pos + 1);
}
private final int jjMoveStringLiteralDfa0_0()
{
   switch(curChar)
   {
      case 35:
         return jjMoveStringLiteralDfa1_0(0x8L);
      case 36:
         return jjMoveStringLiteralDfa1_0(0x4L);
      case 92:
         return jjStartNfaWithStates_0(0, 4, 2);
      default :
         return jjMoveNfa_0(7, 0);
   }
}
private final int jjMoveStringLiteralDfa1_0(long active0)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 123:
         if ((active0 & 0x4L) != 0L)
            return jjStopAtPos(1, 2);
         else if ((active0 & 0x8L) != 0L)
            return jjStopAtPos(1, 3);
         break;
      default :
         break;
   }
   return jjStartNfa_0(0, active0);
}
private final void jjCheckNAdd(int state)
{
   if (jjrounds[state] != jjround)
   {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
   }
}
private final void jjAddStates(int start, int end)
{
   do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
   } while (start++ != end);
}
private final void jjCheckNAddTwoStates(int state1, int state2)
{
   jjCheckNAdd(state1);
   jjCheckNAdd(state2);
}
private final void jjCheckNAddStates(int start, int end)
{
   do {
      jjCheckNAdd(jjnextStates[start]);
   } while (start++ != end);
}
private final void jjCheckNAddStates(int start)
{
   jjCheckNAdd(jjnextStates[start]);
   jjCheckNAdd(jjnextStates[start + 1]);
}
static final long[] jjbitVec0 = {
   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec2 = {
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
};
private final int jjMoveNfa_0(int startState, int curPos)
{
   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 8;
   int i = 1;
   jjstateSet[0] = startState;
   int j, kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 7:
                  if ((0xffffffe7ffffffffL & l) != 0L)
                  {
                     if (kind > 1)
                        kind = 1;
                     jjCheckNAddStates(0, 3);
                  }
                  else if ((0x1800000000L & l) != 0L)
                  {
                     if (kind > 1)
                        kind = 1;
                  }
                  if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 6;
                  else if (curChar == 36)
                     jjstateSet[jjnewStateCnt++] = 4;
                  break;
               case 0:
                  if ((0xffffffe7ffffffffL & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               case 2:
                  if ((0x1800000000L & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               case 3:
                  if (curChar == 36)
                     jjstateSet[jjnewStateCnt++] = 4;
                  break;
               case 4:
                  if ((0xffffffefffffffffL & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               case 5:
                  if (curChar == 35)
                     jjstateSet[jjnewStateCnt++] = 6;
                  break;
               case 6:
                  if ((0xfffffff7ffffffffL & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 7:
                  if ((0xffffffffefffffffL & l) != 0L)
                  {
                     if (kind > 1)
                        kind = 1;
                     jjCheckNAddStates(0, 3);
                  }
                  else if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 0:
                  if ((0xffffffffefffffffL & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               case 1:
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 2;
                  break;
               case 2:
                  if (curChar != 92)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               case 4:
               case 6:
                  if ((0xf7ffffffffffffffL & l) == 0L)
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 7:
               case 0:
               case 4:
               case 6:
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 1)
                     kind = 1;
                  jjCheckNAddStates(0, 3);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
private final int jjStopStringLiteralDfa_1(int pos, long active0)
{
   switch (pos)
   {
      case 0:
         if ((active0 & 0x141d555401c000L) != 0L)
         {
            jjmatchedKind = 53;
            return 42;
         }
         if ((active0 & 0x40000L) != 0L)
            return 1;
         return -1;
      case 1:
         if ((active0 & 0x41554000000L) != 0L)
            return 42;
         if ((active0 & 0x1419400001c000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 1;
            return 42;
         }
         return -1;
      case 2:
         if ((active0 & 0x18000001c000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 2;
            return 42;
         }
         if ((active0 & 0x14014000000000L) != 0L)
            return 42;
         return -1;
      case 3:
         if ((active0 & 0x180000008000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 3;
            return 42;
         }
         if ((active0 & 0x14000L) != 0L)
            return 42;
         return -1;
      case 4:
         if ((active0 & 0x80000008000L) != 0L)
            return 42;
         if ((active0 & 0x100000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 4;
            return 42;
         }
         return -1;
      case 5:
         if ((active0 & 0x100000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 5;
            return 42;
         }
         return -1;
      case 6:
         if ((active0 & 0x100000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 6;
            return 42;
         }
         return -1;
      case 7:
         if ((active0 & 0x100000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 7;
            return 42;
         }
         return -1;
      case 8:
         if ((active0 & 0x100000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 8;
            return 42;
         }
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_1(int pos, long active0)
{
   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
}
private final int jjStartNfaWithStates_1(int pos, int kind, int state)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) { return pos + 1; }
   return jjMoveNfa_1(state, pos + 1);
}
private final int jjMoveStringLiteralDfa0_1()
{
   switch(curChar)
   {
      case 33:
         jjmatchedKind = 37;
         return jjMoveStringLiteralDfa1_1(0x800000000L);
      case 37:
         return jjStopAtPos(0, 51);
      case 38:
         return jjMoveStringLiteralDfa1_1(0x8000000000L);
      case 40:
         return jjStopAtPos(0, 19);
      case 41:
         return jjStopAtPos(0, 20);
      case 42:
         return jjStopAtPos(0, 45);
      case 43:
         return jjStopAtPos(0, 46);
      case 44:
         return jjStopAtPos(0, 24);
      case 45:
         return jjStopAtPos(0, 47);
      case 46:
         return jjStartNfaWithStates_1(0, 18, 1);
      case 47:
         return jjStopAtPos(0, 49);
      case 58:
         return jjStopAtPos(0, 23);
      case 60:
         jjmatchedKind = 27;
         return jjMoveStringLiteralDfa1_1(0x80000000L);
      case 61:
         return jjMoveStringLiteralDfa1_1(0x200000000L);
      case 62:
         jjmatchedKind = 25;
         return jjMoveStringLiteralDfa1_1(0x20000000L);
      case 63:
         return jjStopAtPos(0, 48);
      case 91:
         return jjStopAtPos(0, 21);
      case 93:
         return jjStopAtPos(0, 22);
      case 97:
         return jjMoveStringLiteralDfa1_1(0x10000000000L);
      case 100:
         return jjMoveStringLiteralDfa1_1(0x4000000000000L);
      case 101:
         return jjMoveStringLiteralDfa1_1(0x80400000000L);
      case 102:
         return jjMoveStringLiteralDfa1_1(0x8000L);
      case 103:
         return jjMoveStringLiteralDfa1_1(0x44000000L);
      case 105:
         return jjMoveStringLiteralDfa1_1(0x100000000000L);
      case 108:
         return jjMoveStringLiteralDfa1_1(0x110000000L);
      case 109:
         return jjMoveStringLiteralDfa1_1(0x10000000000000L);
      case 110:
         return jjMoveStringLiteralDfa1_1(0x5000010000L);
      case 111:
         return jjMoveStringLiteralDfa1_1(0x40000000000L);
      case 116:
         return jjMoveStringLiteralDfa1_1(0x4000L);
      case 124:
         return jjMoveStringLiteralDfa1_1(0x20000000000L);
      case 125:
         return jjStopAtPos(0, 17);
      default :
         return jjMoveNfa_1(0, 0);
   }
}
private final int jjMoveStringLiteralDfa1_1(long active0)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(0, active0);
      return 1;
   }
   switch(curChar)
   {
      case 38:
         if ((active0 & 0x8000000000L) != 0L)
            return jjStopAtPos(1, 39);
         break;
      case 61:
         if ((active0 & 0x20000000L) != 0L)
            return jjStopAtPos(1, 29);
         else if ((active0 & 0x80000000L) != 0L)
            return jjStopAtPos(1, 31);
         else if ((active0 & 0x200000000L) != 0L)
            return jjStopAtPos(1, 33);
         else if ((active0 & 0x800000000L) != 0L)
            return jjStopAtPos(1, 35);
         break;
      case 97:
         return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
      case 101:
         if ((active0 & 0x40000000L) != 0L)
            return jjStartNfaWithStates_1(1, 30, 42);
         else if ((active0 & 0x100000000L) != 0L)
            return jjStartNfaWithStates_1(1, 32, 42);
         else if ((active0 & 0x1000000000L) != 0L)
            return jjStartNfaWithStates_1(1, 36, 42);
         break;
      case 105:
         return jjMoveStringLiteralDfa2_1(active0, 0x4000000000000L);
      case 109:
         return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
      case 110:
         return jjMoveStringLiteralDfa2_1(active0, 0x110000000000L);
      case 111:
         return jjMoveStringLiteralDfa2_1(active0, 0x10004000000000L);
      case 113:
         if ((active0 & 0x400000000L) != 0L)
            return jjStartNfaWithStates_1(1, 34, 42);
         break;
      case 114:
         if ((active0 & 0x40000000000L) != 0L)
            return jjStartNfaWithStates_1(1, 42, 42);
         return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
      case 116:
         if ((active0 & 0x4000000L) != 0L)
            return jjStartNfaWithStates_1(1, 26, 42);
         else if ((active0 & 0x10000000L) != 0L)
            return jjStartNfaWithStates_1(1, 28, 42);
         break;
      case 117:
         return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
      case 124:
         if ((active0 & 0x20000000000L) != 0L)
            return jjStopAtPos(1, 41);
         break;
      default :
         break;
   }
   return jjStartNfa_1(0, active0);
}
private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(0, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(1, active0);
      return 2;
   }
   switch(curChar)
   {
      case 100:
         if ((active0 & 0x10000000000L) != 0L)
            return jjStartNfaWithStates_1(2, 40, 42);
         else if ((active0 & 0x10000000000000L) != 0L)
            return jjStartNfaWithStates_1(2, 52, 42);
         break;
      case 108:
         return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
      case 112:
         return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
      case 115:
         return jjMoveStringLiteralDfa3_1(active0, 0x100000000000L);
      case 116:
         if ((active0 & 0x4000000000L) != 0L)
            return jjStartNfaWithStates_1(2, 38, 42);
         break;
      case 117:
         return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
      case 118:
         if ((active0 & 0x4000000000000L) != 0L)
            return jjStartNfaWithStates_1(2, 50, 42);
         break;
      default :
         break;
   }
   return jjStartNfa_1(1, active0);
}
private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(1, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 101:
         if ((active0 & 0x4000L) != 0L)
            return jjStartNfaWithStates_1(3, 14, 42);
         break;
      case 108:
         if ((active0 & 0x10000L) != 0L)
            return jjStartNfaWithStates_1(3, 16, 42);
         break;
      case 115:
         return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
      case 116:
         return jjMoveStringLiteralDfa4_1(active0, 0x180000000000L);
      default :
         break;
   }
   return jjStartNfa_1(2, active0);
}
private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(2, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(3, active0);
      return 4;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa5_1(active0, 0x100000000000L);
      case 101:
         if ((active0 & 0x8000L) != 0L)
            return jjStartNfaWithStates_1(4, 15, 42);
         break;
      case 121:
         if ((active0 & 0x80000000000L) != 0L)
            return jjStartNfaWithStates_1(4, 43, 42);
         break;
      default :
         break;
   }
   return jjStartNfa_1(3, active0);
}
private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(3, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(4, active0);
      return 5;
   }
   switch(curChar)
   {
      case 110:
         return jjMoveStringLiteralDfa6_1(active0, 0x100000000000L);
      default :
         break;
   }
   return jjStartNfa_1(4, active0);
}
private final int jjMoveStringLiteralDfa6_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(4, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(5, active0);
      return 6;
   }
   switch(curChar)
   {
      case 99:
         return jjMoveStringLiteralDfa7_1(active0, 0x100000000000L);
      default :
         break;
   }
   return jjStartNfa_1(5, active0);
}
private final int jjMoveStringLiteralDfa7_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(5, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(6, active0);
      return 7;
   }
   switch(curChar)
   {
      case 101:
         return jjMoveStringLiteralDfa8_1(active0, 0x100000000000L);
      default :
         break;
   }
   return jjStartNfa_1(6, active0);
}
private final int jjMoveStringLiteralDfa8_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(6, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(7, active0);
      return 8;
   }
   switch(curChar)
   {
      case 111:
         return jjMoveStringLiteralDfa9_1(active0, 0x100000000000L);
      default :
         break;
   }
   return jjStartNfa_1(7, active0);
}
private final int jjMoveStringLiteralDfa9_1(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_1(7, old0); 
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_1(8, active0);
      return 9;
   }
   switch(curChar)
   {
      case 102:
         if ((active0 & 0x100000000000L) != 0L)
            return jjStartNfaWithStates_1(9, 44, 42);
         break;
      default :
         break;
   }
   return jjStartNfa_1(8, active0);
}
static final long[] jjbitVec3 = {
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
};
static final long[] jjbitVec4 = {
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
};
static final long[] jjbitVec5 = {
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec6 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
};
static final long[] jjbitVec7 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
};
static final long[] jjbitVec8 = {
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
};
private final int jjMoveNfa_1(int startState, int curPos)
{
   int[] nextStates;
   int startsAt = 0;
   jjnewStateCnt = 42;
   int i = 1;
   jjstateSet[0] = startState;
   int j, kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if ((0x3ff000000000000L & l) != 0L)
                  {
                     if (kind > 9)
                        kind = 9;
                     jjCheckNAddStates(4, 8);
                  }
                  else if ((0x1800000000L & l) != 0L)
                  {
                     if (kind > 53)
                        kind = 53;
                     jjCheckNAddStates(9, 15);
                  }
                  else if (curChar == 39)
                     jjCheckNAddStates(16, 20);
                  else if (curChar == 34)
                     jjCheckNAddStates(21, 25);
                  else if (curChar == 46)
                     jjCheckNAdd(1);
                  break;
               case 42:
                  if ((0x3ff601000000000L & l) != 0L)
                     jjCheckNAddTwoStates(36, 37);
                  else if (curChar == 40)
                  {
                     if (kind > 56)
                        kind = 56;
                  }
                  else if (curChar == 58)
                     jjstateSet[jjnewStateCnt++] = 38;
                  if ((0x3ff001000000000L & l) != 0L)
                  {
                     if (kind > 57)
                        kind = 57;
                     jjCheckNAdd(41);
                  }
                  if ((0x3ff001000000000L & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  if ((0x3ff001000000000L & l) != 0L)
                     jjCheckNAddStates(26, 28);
                  if ((0x3ff001000000000L & l) != 0L)
                  {
                     if (kind > 53)
                        kind = 53;
                     jjCheckNAdd(34);
                  }
                  break;
               case 1:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAddTwoStates(1, 2);
                  break;
               case 3:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(4);
                  break;
               case 4:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAdd(4);
                  break;
               case 5:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 9)
                     kind = 9;
                  jjCheckNAddStates(4, 8);
                  break;
               case 6:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 9)
                     kind = 9;
                  jjCheckNAdd(6);
                  break;
               case 7:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(7, 8);
                  break;
               case 8:
                  if (curChar != 46)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAddTwoStates(9, 10);
                  break;
               case 9:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAddTwoStates(9, 10);
                  break;
               case 11:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(12);
                  break;
               case 12:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAdd(12);
                  break;
               case 13:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(13, 14);
                  break;
               case 15:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(16);
                  break;
               case 16:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 10)
                     kind = 10;
                  jjCheckNAdd(16);
                  break;
               case 17:
                  if (curChar == 34)
                     jjCheckNAddStates(21, 25);
                  break;
               case 18:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddStates(29, 31);
                  break;
               case 20:
                  if (curChar == 34)
                     jjCheckNAddStates(29, 31);
                  break;
               case 21:
                  if (curChar == 34 && kind > 12)
                     kind = 12;
                  break;
               case 22:
                  if ((0xfffffffbffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(22, 23);
                  break;
               case 24:
                  if ((0xfffffffbffffffffL & l) != 0L && kind > 13)
                     kind = 13;
                  break;
               case 25:
                  if (curChar == 39)
                     jjCheckNAddStates(16, 20);
                  break;
               case 26:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddStates(32, 34);
                  break;
               case 28:
                  if (curChar == 39)
                     jjCheckNAddStates(32, 34);
                  break;
               case 29:
                  if (curChar == 39 && kind > 12)
                     kind = 12;
                  break;
               case 30:
                  if ((0xffffff7fffffffffL & l) != 0L)
                     jjCheckNAddTwoStates(30, 31);
                  break;
               case 32:
                  if ((0xffffff7fffffffffL & l) != 0L && kind > 13)
                     kind = 13;
                  break;
               case 33:
                  if ((0x1800000000L & l) == 0L)
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAddStates(9, 15);
                  break;
               case 34:
                  if ((0x3ff001000000000L & l) == 0L)
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAdd(34);
                  break;
               case 35:
                  if ((0x3ff001000000000L & l) != 0L)
                     jjCheckNAddStates(26, 28);
                  break;
               case 36:
                  if ((0x3ff601000000000L & l) != 0L)
                     jjCheckNAddTwoStates(36, 37);
                  break;
               case 37:
                  if (curChar == 58)
                     jjstateSet[jjnewStateCnt++] = 38;
                  break;
               case 38:
                  if ((0x1800000000L & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 39:
                  if ((0x3ff001000000000L & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 40:
                  if (curChar == 40 && kind > 56)
                     kind = 56;
                  break;
               case 41:
                  if ((0x3ff001000000000L & l) == 0L)
                     break;
                  if (kind > 57)
                     kind = 57;
                  jjCheckNAdd(41);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else if (curChar < 128)
      {
         long l = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAddStates(9, 15);
                  break;
               case 42:
                  if ((0x7fffffe87fffffeL & l) != 0L)
                  {
                     if (kind > 57)
                        kind = 57;
                     jjCheckNAdd(41);
                  }
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddTwoStates(36, 37);
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddStates(26, 28);
                  if ((0x7fffffe87fffffeL & l) != 0L)
                  {
                     if (kind > 53)
                        kind = 53;
                     jjCheckNAdd(34);
                  }
                  break;
               case 2:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(35, 36);
                  break;
               case 10:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(37, 38);
                  break;
               case 14:
                  if ((0x2000000020L & l) != 0L)
                     jjAddStates(39, 40);
                  break;
               case 18:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjCheckNAddStates(29, 31);
                  break;
               case 19:
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 20;
                  break;
               case 20:
                  if (curChar == 92)
                     jjCheckNAddStates(29, 31);
                  break;
               case 22:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjAddStates(41, 42);
                  break;
               case 23:
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 24;
                  break;
               case 24:
               case 32:
                  if ((0xffffffffefffffffL & l) != 0L && kind > 13)
                     kind = 13;
                  break;
               case 26:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjCheckNAddStates(32, 34);
                  break;
               case 27:
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 28;
                  break;
               case 28:
                  if (curChar == 92)
                     jjCheckNAddStates(32, 34);
                  break;
               case 30:
                  if ((0xffffffffefffffffL & l) != 0L)
                     jjAddStates(43, 44);
                  break;
               case 31:
                  if (curChar == 92)
                     jjstateSet[jjnewStateCnt++] = 32;
                  break;
               case 34:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAdd(34);
                  break;
               case 35:
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddStates(26, 28);
                  break;
               case 36:
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddTwoStates(36, 37);
                  break;
               case 38:
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 39:
                  if ((0x7fffffe87fffffeL & l) != 0L)
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 41:
                  if ((0x7fffffe87fffffeL & l) == 0L)
                     break;
                  if (kind > 57)
                     kind = 57;
                  jjCheckNAdd(41);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      else
      {
         int hiByte = (int)(curChar >> 8);
         int i1 = hiByte >> 6;
         long l1 = 1L << (hiByte & 077);
         int i2 = (curChar & 0xff) >> 6;
         long l2 = 1L << (curChar & 077);
         MatchLoop: do
         {
            switch(jjstateSet[--i])
            {
               case 0:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAddStates(9, 15);
                  break;
               case 42:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                  {
                     if (kind > 53)
                        kind = 53;
                     jjCheckNAdd(34);
                  }
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(26, 28);
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(36, 37);
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(39, 40);
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                  {
                     if (kind > 57)
                        kind = 57;
                     jjCheckNAdd(41);
                  }
                  break;
               case 18:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(29, 31);
                  break;
               case 22:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(41, 42);
                  break;
               case 24:
               case 32:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                     kind = 13;
                  break;
               case 26:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(32, 34);
                  break;
               case 30:
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                     jjAddStates(43, 44);
                  break;
               case 34:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 53)
                     kind = 53;
                  jjCheckNAdd(34);
                  break;
               case 35:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddStates(26, 28);
                  break;
               case 36:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(36, 37);
                  break;
               case 38:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 39:
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                     jjCheckNAddTwoStates(39, 40);
                  break;
               case 41:
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                     break;
                  if (kind > 57)
                     kind = 57;
                  jjCheckNAdd(41);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
         jjmatchedKind = kind;
         jjmatchedPos = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 42 - (jjnewStateCnt = startsAt)))
         return curPos;
      try { curChar = input_stream.readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
}
static final int[] jjnextStates = {
   0, 1, 3, 5, 6, 7, 8, 13, 14, 34, 35, 36, 37, 39, 40, 41, 
   26, 27, 29, 30, 31, 18, 19, 21, 22, 23, 35, 36, 37, 18, 19, 21, 
   26, 27, 29, 3, 4, 11, 12, 15, 16, 22, 23, 30, 31, 
};
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec2[i2] & l2) != 0L);
      default : 
         if ((jjbitVec0[i1] & l1) != 0L)
            return true;
         return false;
   }
}
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
{
   switch(hiByte)
   {
      case 0:
         return ((jjbitVec4[i2] & l2) != 0L);
      case 48:
         return ((jjbitVec5[i2] & l2) != 0L);
      case 49:
         return ((jjbitVec6[i2] & l2) != 0L);
      case 51:
         return ((jjbitVec7[i2] & l2) != 0L);
      case 61:
         return ((jjbitVec8[i2] & l2) != 0L);
      default : 
         if ((jjbitVec3[i1] & l1) != 0L)
            return true;
         return false;
   }
}
public static final String[] jjstrLiteralImages = {
"", null, "\44\173", "\43\173", null, null, null, null, null, null, null, null, 
null, null, "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\175", 
"\56", "\50", "\51", "\133", "\135", "\72", "\54", "\76", "\147\164", "\74", 
"\154\164", "\76\75", "\147\145", "\74\75", "\154\145", "\75\75", "\145\161", "\41\75", 
"\156\145", "\41", "\156\157\164", "\46\46", "\141\156\144", "\174\174", "\157\162", 
"\145\155\160\164\171", "\151\156\163\164\141\156\143\145\157\146", "\52", "\53", "\55", "\77", "\57", 
"\144\151\166", "\45", "\155\157\144", null, null, null, null, null, null, null, null, null, };
public static final String[] lexStateNames = {
   "DEFAULT", 
   "IN_EXPRESSION", 
};
public static final int[] jjnewLexState = {
   -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
};
static final long[] jjtoToken = {
   0x233ffffffffff60fL, 
};
static final long[] jjtoSkip = {
   0x1f0L, 
};
protected SimpleCharStream input_stream;
private final int[] jjrounds = new int[42];
private final int[] jjstateSet = new int[84];
protected char curChar;
public ELParserTokenManager(SimpleCharStream stream){
   if (SimpleCharStream.staticFlag)
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
   input_stream = stream;
}
public ELParserTokenManager(SimpleCharStream stream, int lexState){
   this(stream);
   SwitchTo(lexState);
}
public void ReInit(SimpleCharStream stream)
{
   jjmatchedPos = jjnewStateCnt = 0;
   curLexState = defaultLexState;
   input_stream = stream;
   ReInitRounds();
}
private final void ReInitRounds()
{
   int i;
   jjround = 0x80000001;
   for (i = 42; i-- > 0;)
      jjrounds[i] = 0x80000000;
}
public void ReInit(SimpleCharStream stream, int lexState)
{
   ReInit(stream);
   SwitchTo(lexState);
}
public void SwitchTo(int lexState)
{
   if (lexState >= 2 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
   else
      curLexState = lexState;
}

protected Token jjFillToken()
{
   Token t = Token.newToken(jjmatchedKind);
   t.kind = jjmatchedKind;
   String im = jjstrLiteralImages[jjmatchedKind];
   t.image = (im == null) ? input_stream.GetImage() : im;
   t.beginLine = input_stream.getBeginLine();
   t.beginColumn = input_stream.getBeginColumn();
   t.endLine = input_stream.getEndLine();
   t.endColumn = input_stream.getEndColumn();
   return t;
}

int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;
				jjmatchedKind = 1;
				return 4;
			}
			if ((active0 & 0x8L) != 0L) {
				jjmatchedKind = 1;
				return 6;
			}
			return -1;
		default:
			return -1;
		}
	}

public Token getNextToken() 
{
  int kind;
  Token specialToken = null;
  Token matchedToken;
  int curPos = 0;

  EOFLoop :
  for (;;)
  {   
   try   
   {     
      curChar = input_stream.BeginToken();
   }     
   catch(java.io.IOException e)
   {        
      jjmatchedKind = 0;
      matchedToken = jjFillToken();
      return matchedToken;
   }

   switch(curLexState)
   {
     case 0:
       jjmatchedKind = 0x7fffffff;
       jjmatchedPos = 0;
       curPos = jjMoveStringLiteralDfa0_0();
       break;
     case 1:
       try { input_stream.backup(0);
          while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
             curChar = input_stream.BeginToken();
       }
       catch (java.io.IOException e1) { continue EOFLoop; }
       jjmatchedKind = 0x7fffffff;
       jjmatchedPos = 0;
       curPos = jjMoveStringLiteralDfa0_1();
       if (jjmatchedPos == 0 && jjmatchedKind > 61)
       {
          jjmatchedKind = 61;
       }
       break;
   }
     if (jjmatchedKind != 0x7fffffff)
     {
        if (jjmatchedPos + 1 < curPos)
           input_stream.backup(curPos - jjmatchedPos - 1);
        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
        {
           matchedToken = jjFillToken();
       if (jjnewLexState[jjmatchedKind] != -1)
         curLexState = jjnewLexState[jjmatchedKind];
           return matchedToken;
        }
        else
        {
         if (jjnewLexState[jjmatchedKind] != -1)
           curLexState = jjnewLexState[jjmatchedKind];
           continue EOFLoop;
        }
     }
     int error_line = input_stream.getEndLine();
     int error_column = input_stream.getEndColumn();
     String error_after = null;
     boolean EOFSeen = false;
     try { input_stream.readChar(); input_stream.backup(1); }
     catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
           error_line++;
           error_column = 0;
        }
        else
           error_column++;
     }
     if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
     }
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  }
}

	private final int jjMoveStringLiteralDfa0_0() {
		switch (curChar) {
		case 35:
			return jjMoveStringLiteralDfa1_0(0x8L);
		case 36:
			return jjMoveStringLiteralDfa1_0(0x4L);
		case 92:
			return jjStartNfaWithStates_0(0, 4, 2);
		default:
			return jjMoveNfa_0(7, 0);
		}
	}

	private final int jjMoveStringLiteralDfa1_0(long active0) {
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_0(0, active0);
			return 1;
		}
		switch (curChar) {
		case 123:
			if ((active0 & 0x4L) != 0L)
				return jjStopAtPos(1, 2);
			else if ((active0 & 0x8L) != 0L)
				return jjStopAtPos(1, 3);
			break;
		default:
			break;
		}
		return jjStartNfa_0(0, active0);
	}

	private final void jjCheckNAdd(int state) {
		if (jjrounds[state] != jjround) {
			jjstateSet[jjnewStateCnt++] = state;
			jjrounds[state] = jjround;
		}
	}

	private final void jjAddStates(int start, int end) {
		do {
			jjstateSet[jjnewStateCnt++] = jjnextStates[start];
		} while (start++ != end);
	}

	private final void jjCheckNAddTwoStates(int state1, int state2) {
		jjCheckNAdd(state1);
		jjCheckNAdd(state2);
	}

	private final void jjCheckNAddStates(int start, int end) {
		do {
			jjCheckNAdd(jjnextStates[start]);
		} while (start++ != end);
	}

	private final void jjCheckNAddStates(int start) {
		jjCheckNAdd(jjnextStates[start]);
		jjCheckNAdd(jjnextStates[start + 1]);
	}

	static final long[] jjbitVec0 = { 0xfffffffffffffffeL, 0xffffffffffffffffL,
			0xffffffffffffffffL, 0xffffffffffffffffL };

	static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
			0xffffffffffffffffL };

	private final int jjMoveNfa_0(int startState, int curPos) {
		int[] nextStates;
		int startsAt = 0;
		jjnewStateCnt = 8;
		int i = 1;
		jjstateSet[0] = startState;
		int j, kind = 0x7fffffff;
		for (;;) {
			if (++jjround == 0x7fffffff)
				ReInitRounds();
			if (curChar < 64) {
				long l = 1L << curChar;
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 7:
						if ((0xffffffe7ffffffffL & l) != 0L) {
							if (kind > 1)
								kind = 1;
							jjCheckNAddStates(0, 3);
						} else if ((0x1800000000L & l) != 0L) {
							if (kind > 1)
								kind = 1;
						}
						if (curChar == 35)
							jjstateSet[jjnewStateCnt++] = 6;
						else if (curChar == 36)
							jjstateSet[jjnewStateCnt++] = 4;
						break;
					case 0:
						if ((0xffffffe7ffffffffL & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					case 2:
						if ((0x1800000000L & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					case 3:
						if (curChar == 36)
							jjstateSet[jjnewStateCnt++] = 4;
						break;
					case 4:
						if ((0xffffffefffffffffL & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					case 5:
						if (curChar == 35)
							jjstateSet[jjnewStateCnt++] = 6;
						break;
					case 6:
						if ((0xfffffff7ffffffffL & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			} else if (curChar < 128) {
				long l = 1L << (curChar & 077);
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 7:
						if ((0xffffffffefffffffL & l) != 0L) {
							if (kind > 1)
								kind = 1;
							jjCheckNAddStates(0, 3);
						} else if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 2;
						break;
					case 0:
						if ((0xffffffffefffffffL & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					case 1:
						if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 2;
						break;
					case 2:
						if (curChar != 92)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					case 4:
					case 6:
						if ((0xf7ffffffffffffffL & l) == 0L)
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			} else {
				int hiByte = (int) (curChar >> 8);
				int i1 = hiByte >> 6;
				long l1 = 1L << (hiByte & 077);
				int i2 = (curChar & 0xff) >> 6;
				long l2 = 1L << (curChar & 077);
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 7:
					case 0:
					case 4:
					case 6:
						if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
							break;
						if (kind > 1)
							kind = 1;
						jjCheckNAddStates(0, 3);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			}
			if (kind != 0x7fffffff) {
				jjmatchedKind = kind;
				jjmatchedPos = curPos;
				kind = 0x7fffffff;
			}
			++curPos;
			if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
				return curPos;
			try {
				curChar = input_stream.readChar();
			} catch (java.io.IOException e) {
				return curPos;
			}
		}
	}

	private final int jjStopStringLiteralDfa_1(int pos, long active0) {
		switch (pos) {
		case 0:
			if ((active0 & 0x141d555401c000L) != 0L) {
				jjmatchedKind = 53;
				return 41;
			}
			if ((active0 & 0x40000L) != 0L)
				return 1;
			return -1;
		case 1:
			if ((active0 & 0x41554000000L) != 0L)
				return 42;
			if ((active0 & 0x1419400001c000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 1;
				return 42;
			}
			return -1;
		case 2:
			if ((active0 & 0x14014000000000L) != 0L)
				return 42;
			if ((active0 & 0x18000001c000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 2;
				return 42;
			}
			return -1;
		case 3:
			if ((active0 & 0x14000L) != 0L)
				return 42;
			if ((active0 & 0x180000008000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 3;
				return 42;
			}
			return -1;
		case 4:
			if ((active0 & 0x80000008000L) != 0L)
				return 42;
			if ((active0 & 0x100000000000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 4;
				return 42;
			}
			return -1;
		case 5:
			if ((active0 & 0x100000000000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 5;
				return 42;
			}
			return -1;
		case 6:
			if ((active0 & 0x100000000000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 6;
				return 42;
			}
			return -1;
		case 7:
			if ((active0 & 0x100000000000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 7;
				return 42;
			}
			return -1;
		case 8:
			if ((active0 & 0x100000000000L) != 0L) {
				jjmatchedKind = 53;
				jjmatchedPos = 8;
				return 42;
			}
			return -1;
		default:
			return -1;
		}
	}

	private final int jjStartNfa_1(int pos, long active0) {
		return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
	}

	private final int jjStartNfaWithStates_1(int pos, int kind, int state) {
		jjmatchedKind = kind;
		jjmatchedPos = pos;
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			return pos + 1;
		}
		return jjMoveNfa_1(state, pos + 1);
	}

	private final int jjMoveStringLiteralDfa0_1() {
		switch (curChar) {
		case 33:
			jjmatchedKind = 37;
			return jjMoveStringLiteralDfa1_1(0x800000000L);
		case 37:
			return jjStopAtPos(0, 51);
		case 38:
			return jjMoveStringLiteralDfa1_1(0x8000000000L);
		case 40:
			return jjStopAtPos(0, 19);
		case 41:
			return jjStopAtPos(0, 20);
		case 42:
			return jjStopAtPos(0, 45);
		case 43:
			return jjStopAtPos(0, 46);
		case 44:
			return jjStopAtPos(0, 24);
		case 45:
			return jjStopAtPos(0, 47);
		case 46:
			return jjStartNfaWithStates_1(0, 18, 1);
		case 47:
			return jjStopAtPos(0, 49);
		case 58:
			return jjStopAtPos(0, 23);
		case 60:
			jjmatchedKind = 27;
			return jjMoveStringLiteralDfa1_1(0x80000000L);
		case 61:
			return jjMoveStringLiteralDfa1_1(0x200000000L);
		case 62:
			jjmatchedKind = 25;
			return jjMoveStringLiteralDfa1_1(0x20000000L);
		case 63:
			return jjStopAtPos(0, 48);
		case 91:
			return jjStopAtPos(0, 21);
		case 93:
			return jjStopAtPos(0, 22);
		case 97:
			return jjMoveStringLiteralDfa1_1(0x10000000000L);
		case 100:
			return jjMoveStringLiteralDfa1_1(0x4000000000000L);
		case 101:
			return jjMoveStringLiteralDfa1_1(0x80400000000L);
		case 102:
			return jjMoveStringLiteralDfa1_1(0x8000L);
		case 103:
			return jjMoveStringLiteralDfa1_1(0x44000000L);
		case 105:
			return jjMoveStringLiteralDfa1_1(0x100000000000L);
		case 108:
			return jjMoveStringLiteralDfa1_1(0x110000000L);
		case 109:
			return jjMoveStringLiteralDfa1_1(0x10000000000000L);
		case 110:
			return jjMoveStringLiteralDfa1_1(0x5000010000L);
		case 111:
			return jjMoveStringLiteralDfa1_1(0x40000000000L);
		case 116:
			return jjMoveStringLiteralDfa1_1(0x4000L);
		case 124:
			return jjMoveStringLiteralDfa1_1(0x20000000000L);
		case 125:
			return jjStopAtPos(0, 17);
		default:
			return jjMoveNfa_1(0, 0);
		}
	}

	private final int jjMoveStringLiteralDfa1_1(long active0) {
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(0, active0);
			return 1;
		}
		switch (curChar) {
		case 38:
			if ((active0 & 0x8000000000L) != 0L)
				return jjStopAtPos(1, 39);
			break;
		case 61:
			if ((active0 & 0x20000000L) != 0L)
				return jjStopAtPos(1, 29);
			else if ((active0 & 0x80000000L) != 0L)
				return jjStopAtPos(1, 31);
			else if ((active0 & 0x200000000L) != 0L)
				return jjStopAtPos(1, 33);
			else if ((active0 & 0x800000000L) != 0L)
				return jjStopAtPos(1, 35);
			break;
		case 97:
			return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
		case 101:
			if ((active0 & 0x40000000L) != 0L)
				return jjStartNfaWithStates_1(1, 30, 42);
			else if ((active0 & 0x100000000L) != 0L)
				return jjStartNfaWithStates_1(1, 32, 42);
			else if ((active0 & 0x1000000000L) != 0L)
				return jjStartNfaWithStates_1(1, 36, 42);
			break;
		case 105:
			return jjMoveStringLiteralDfa2_1(active0, 0x4000000000000L);
		case 109:
			return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
		case 110:
			return jjMoveStringLiteralDfa2_1(active0, 0x110000000000L);
		case 111:
			return jjMoveStringLiteralDfa2_1(active0, 0x10004000000000L);
		case 113:
			if ((active0 & 0x400000000L) != 0L)
				return jjStartNfaWithStates_1(1, 34, 42);
			break;
		case 114:
			if ((active0 & 0x40000000000L) != 0L)
				return jjStartNfaWithStates_1(1, 42, 42);
			return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
		case 116:
			if ((active0 & 0x4000000L) != 0L)
				return jjStartNfaWithStates_1(1, 26, 42);
			else if ((active0 & 0x10000000L) != 0L)
				return jjStartNfaWithStates_1(1, 28, 42);
			break;
		case 117:
			return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
		case 124:
			if ((active0 & 0x20000000000L) != 0L)
				return jjStopAtPos(1, 41);
			break;
		default:
			break;
		}
		return jjStartNfa_1(0, active0);
	}

	private final int jjMoveStringLiteralDfa2_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(0, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(1, active0);
			return 2;
		}
		switch (curChar) {
		case 100:
			if ((active0 & 0x10000000000L) != 0L)
				return jjStartNfaWithStates_1(2, 40, 42);
			else if ((active0 & 0x10000000000000L) != 0L)
				return jjStartNfaWithStates_1(2, 52, 42);
			break;
		case 108:
			return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
		case 112:
			return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
		case 115:
			return jjMoveStringLiteralDfa3_1(active0, 0x100000000000L);
		case 116:
			if ((active0 & 0x4000000000L) != 0L)
				return jjStartNfaWithStates_1(2, 38, 42);
			break;
		case 117:
			return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
		case 118:
			if ((active0 & 0x4000000000000L) != 0L)
				return jjStartNfaWithStates_1(2, 50, 42);
			break;
		default:
			break;
		}
		return jjStartNfa_1(1, active0);
	}

	private final int jjMoveStringLiteralDfa3_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(1, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(2, active0);
			return 3;
		}
		switch (curChar) {
		case 101:
			if ((active0 & 0x4000L) != 0L)
				return jjStartNfaWithStates_1(3, 14, 42);
			break;
		case 108:
			if ((active0 & 0x10000L) != 0L)
				return jjStartNfaWithStates_1(3, 16, 42);
			break;
		case 115:
			return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
		case 116:
			return jjMoveStringLiteralDfa4_1(active0, 0x180000000000L);
		default:
			break;
		}
		return jjStartNfa_1(2, active0);
	}

	private final int jjMoveStringLiteralDfa4_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(2, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(3, active0);
			return 4;
		}
		switch (curChar) {
		case 97:
			return jjMoveStringLiteralDfa5_1(active0, 0x100000000000L);
		case 101:
			if ((active0 & 0x8000L) != 0L)
				return jjStartNfaWithStates_1(4, 15, 42);
			break;
		case 121:
			if ((active0 & 0x80000000000L) != 0L)
				return jjStartNfaWithStates_1(4, 43, 42);
			break;
		default:
			break;
		}
		return jjStartNfa_1(3, active0);
	}

	private final int jjMoveStringLiteralDfa5_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(3, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(4, active0);
			return 5;
		}
		switch (curChar) {
		case 110:
			return jjMoveStringLiteralDfa6_1(active0, 0x100000000000L);
		default:
			break;
		}
		return jjStartNfa_1(4, active0);
	}

	private final int jjMoveStringLiteralDfa6_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(4, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(5, active0);
			return 6;
		}
		switch (curChar) {
		case 99:
			return jjMoveStringLiteralDfa7_1(active0, 0x100000000000L);
		default:
			break;
		}
		return jjStartNfa_1(5, active0);
	}

	private final int jjMoveStringLiteralDfa7_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(5, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(6, active0);
			return 7;
		}
		switch (curChar) {
		case 101:
			return jjMoveStringLiteralDfa8_1(active0, 0x100000000000L);
		default:
			break;
		}
		return jjStartNfa_1(6, active0);
	}

	private final int jjMoveStringLiteralDfa8_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(6, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(7, active0);
			return 8;
		}
		switch (curChar) {
		case 111:
			return jjMoveStringLiteralDfa9_1(active0, 0x100000000000L);
		default:
			break;
		}
		return jjStartNfa_1(7, active0);
	}

	private final int jjMoveStringLiteralDfa9_1(long old0, long active0) {
		if (((active0 &= old0)) == 0L)
			return jjStartNfa_1(7, old0);
		try {
			curChar = input_stream.readChar();
		} catch (java.io.IOException e) {
			jjStopStringLiteralDfa_1(8, active0);
			return 9;
		}
		switch (curChar) {
		case 102:
			if ((active0 & 0x100000000000L) != 0L)
				return jjStartNfaWithStates_1(9, 44, 42);
			break;
		default:
			break;
		}
		return jjStartNfa_1(8, active0);
	}

	static final long[] jjbitVec3 = { 0x1ff00000fffffffeL, 0xffffffffffffc000L,
			0xffffffffL, 0x600000000000000L };

	static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL };

	static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
			0xffffffffffffffffL, 0xffffffffffffffffL };

	static final long[] jjbitVec6 = { 0xffffffffffffffffL, 0xffffffffffffffffL,
			0xffffL, 0x0L };

	static final long[] jjbitVec7 = { 0xffffffffffffffffL, 0xffffffffffffffffL,
			0x0L, 0x0L };

	static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };

	private final int jjMoveNfa_1(int startState, int curPos) {
		int[] nextStates;
		int startsAt = 0;
		jjnewStateCnt = 41;
		int i = 1;
		jjstateSet[0] = startState;
		int j, kind = 0x7fffffff;
		for (;;) {
			if (++jjround == 0x7fffffff)
				ReInitRounds();
			if (curChar < 64) {
				long l = 1L << curChar;
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 41:
						if ((0x3ff001000000000L & l) != 0L) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						} else if ((0x600000000000L & l) != 0L)
							jjCheckNAddStates(4, 6);
						else if (curChar == 58) {
							if (kind > 54)
								kind = 54;
						}
						if ((0x3ff001000000000L & l) != 0L)
							jjCheckNAddStates(7, 10);
						if ((0x3ff001000000000L & l) != 0L) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						if ((0x1800000000L & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 0:
						if ((0x3ff000000000000L & l) != 0L) {
							if (kind > 9)
								kind = 9;
							jjCheckNAddStates(15, 19);
						} else if ((0x1800000000L & l) != 0L) {
							if (kind > 53)
								kind = 53;
							jjCheckNAddStates(20, 25);
						} else if (curChar == 39)
							jjCheckNAddStates(26, 30);
						else if (curChar == 34)
							jjCheckNAddStates(31, 35);
						else if (curChar == 46)
							jjCheckNAdd(1);
						break;
					case 42:
						if ((0x3ff001000000000L & l) != 0L) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						} else if ((0x600000000000L & l) != 0L)
							jjCheckNAddStates(4, 6);
						else if (curChar == 58) {
							if (kind > 54)
								kind = 54;
						}
						if ((0x3ff001000000000L & l) != 0L)
							jjCheckNAddStates(11, 14);
						if ((0x3ff001000000000L & l) != 0L)
							jjCheckNAddStates(7, 10);
						if ((0x3ff001000000000L & l) != 0L) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						if ((0x1800000000L & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 1:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAddTwoStates(1, 2);
						break;
					case 3:
						if ((0x280000000000L & l) != 0L)
							jjCheckNAdd(4);
						break;
					case 4:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAdd(4);
						break;
					case 5:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 9)
							kind = 9;
						jjCheckNAddStates(15, 19);
						break;
					case 6:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 9)
							kind = 9;
						jjCheckNAdd(6);
						break;
					case 7:
						if ((0x3ff000000000000L & l) != 0L)
							jjCheckNAddTwoStates(7, 8);
						break;
					case 8:
						if (curChar != 46)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAddTwoStates(9, 10);
						break;
					case 9:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAddTwoStates(9, 10);
						break;
					case 11:
						if ((0x280000000000L & l) != 0L)
							jjCheckNAdd(12);
						break;
					case 12:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAdd(12);
						break;
					case 13:
						if ((0x3ff000000000000L & l) != 0L)
							jjCheckNAddTwoStates(13, 14);
						break;
					case 15:
						if ((0x280000000000L & l) != 0L)
							jjCheckNAdd(16);
						break;
					case 16:
						if ((0x3ff000000000000L & l) == 0L)
							break;
						if (kind > 10)
							kind = 10;
						jjCheckNAdd(16);
						break;
					case 17:
						if (curChar == 34)
							jjCheckNAddStates(31, 35);
						break;
					case 18:
						if ((0xfffffffbffffffffL & l) != 0L)
							jjCheckNAddStates(36, 38);
						break;
					case 20:
						if (curChar == 34)
							jjCheckNAddStates(36, 38);
						break;
					case 21:
						if (curChar == 34 && kind > 12)
							kind = 12;
						break;
					case 22:
						if ((0xfffffffbffffffffL & l) != 0L)
							jjCheckNAddTwoStates(22, 23);
						break;
					case 24:
						if ((0xfffffffbffffffffL & l) != 0L && kind > 13)
							kind = 13;
						break;
					case 25:
						if (curChar == 39)
							jjCheckNAddStates(26, 30);
						break;
					case 26:
						if ((0xffffff7fffffffffL & l) != 0L)
							jjCheckNAddStates(39, 41);
						break;
					case 28:
						if (curChar == 39)
							jjCheckNAddStates(39, 41);
						break;
					case 29:
						if (curChar == 39 && kind > 12)
							kind = 12;
						break;
					case 30:
						if ((0xffffff7fffffffffL & l) != 0L)
							jjCheckNAddTwoStates(30, 31);
						break;
					case 32:
						if ((0xffffff7fffffffffL & l) != 0L && kind > 13)
							kind = 13;
						break;
					case 33:
						if ((0x1800000000L & l) == 0L)
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAddStates(20, 25);
						break;
					case 34:
						if ((0x3ff001000000000L & l) == 0L)
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAdd(34);
						break;
					case 35:
						if ((0x3ff001000000000L & l) != 0L)
							jjCheckNAddStates(7, 10);
						break;
					case 36:
						if ((0x1800000000L & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 37:
						if ((0x3ff001000000000L & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 38:
						if ((0x600000000000L & l) != 0L)
							jjCheckNAddStates(4, 6);
						break;
					case 39:
						if (curChar == 58 && kind > 54)
							kind = 54;
						break;
					case 40:
						if ((0x3ff001000000000L & l) == 0L)
							break;
						if (kind > 55)
							kind = 55;
						jjCheckNAdd(40);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			} else if (curChar < 128) {
				long l = 1L << (curChar & 077);
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 41:
						if ((0x7fffffe87fffffeL & l) != 0L) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						}
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(11, 14);
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(7, 10);
						if ((0x7fffffe87fffffeL & l) != 0L) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						break;
					case 0:
						if ((0x7fffffe87fffffeL & l) == 0L)
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAddStates(20, 25);
						break;
					case 42:
						if ((0x7fffffe87fffffeL & l) != 0L) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						}
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(11, 14);
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(11, 14);
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(7, 10);
						if ((0x7fffffe87fffffeL & l) != 0L) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						break;
					case 2:
						if ((0x2000000020L & l) != 0L)
							jjAddStates(42, 43);
						break;
					case 10:
						if ((0x2000000020L & l) != 0L)
							jjAddStates(44, 45);
						break;
					case 14:
						if ((0x2000000020L & l) != 0L)
							jjAddStates(46, 47);
						break;
					case 18:
						if ((0xffffffffefffffffL & l) != 0L)
							jjCheckNAddStates(36, 38);
						break;
					case 19:
						if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 20;
						break;
					case 20:
						if (curChar == 92)
							jjCheckNAddStates(36, 38);
						break;
					case 22:
						if ((0xffffffffefffffffL & l) != 0L)
							jjAddStates(48, 49);
						break;
					case 23:
						if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 24;
						break;
					case 24:
					case 32:
						if ((0xffffffffefffffffL & l) != 0L && kind > 13)
							kind = 13;
						break;
					case 26:
						if ((0xffffffffefffffffL & l) != 0L)
							jjCheckNAddStates(39, 41);
						break;
					case 27:
						if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 28;
						break;
					case 28:
						if (curChar == 92)
							jjCheckNAddStates(39, 41);
						break;
					case 30:
						if ((0xffffffffefffffffL & l) != 0L)
							jjAddStates(50, 51);
						break;
					case 31:
						if (curChar == 92)
							jjstateSet[jjnewStateCnt++] = 32;
						break;
					case 34:
						if ((0x7fffffe87fffffeL & l) == 0L)
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAdd(34);
						break;
					case 35:
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(7, 10);
						break;
					case 36:
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 37:
						if ((0x7fffffe87fffffeL & l) != 0L)
							jjCheckNAddStates(11, 14);
						break;
					case 40:
						if ((0x7fffffe87fffffeL & l) == 0L)
							break;
						if (kind > 55)
							kind = 55;
						jjCheckNAdd(40);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			} else {
				int hiByte = (int) (curChar >> 8);
				int i1 = hiByte >> 6;
				long l1 = 1L << (hiByte & 077);
				int i2 = (curChar & 0xff) >> 6;
				long l2 = 1L << (curChar & 077);
				MatchLoop: do {
					switch (jjstateSet[--i]) {
					case 41:
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(7, 10);
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(11, 14);
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						}
						break;
					case 0:
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAddStates(20, 25);
						break;
					case 42:
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
							if (kind > 53)
								kind = 53;
							jjCheckNAdd(34);
						}
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(7, 10);
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(11, 14);
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(11, 14);
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
							if (kind > 55)
								kind = 55;
							jjCheckNAdd(40);
						}
						break;
					case 18:
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
							jjAddStates(36, 38);
						break;
					case 22:
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
							jjAddStates(48, 49);
						break;
					case 24:
					case 32:
						if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
							kind = 13;
						break;
					case 26:
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
							jjAddStates(39, 41);
						break;
					case 30:
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
							jjAddStates(50, 51);
						break;
					case 34:
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
							break;
						if (kind > 53)
							kind = 53;
						jjCheckNAdd(34);
						break;
					case 35:
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(7, 10);
						break;
					case 36:
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(11, 14);
						break;
					case 37:
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
							jjCheckNAddStates(11, 14);
						break;
					case 40:
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
							break;
						if (kind > 55)
							kind = 55;
						jjCheckNAdd(40);
						break;
					default:
						break;
					}
				} while (i != startsAt);
			}
			if (kind != 0x7fffffff) {
				jjmatchedKind = kind;
				jjmatchedPos = curPos;
				kind = 0x7fffffff;
			}
			++curPos;
			if ((i = jjnewStateCnt) == (startsAt = 41 - (jjnewStateCnt = startsAt)))
				return curPos;
			try {
				curChar = input_stream.readChar();
			} catch (java.io.IOException e) {
				return curPos;
			}
		}
	}

	static final int[] jjnextStates = { 0, 1, 3, 5, 36, 38, 39, 35, 36, 38, 39,
			36, 37, 38, 39, 6, 7, 8, 13, 14, 34, 35, 36, 38, 39, 40, 26, 27,
			29, 30, 31, 18, 19, 21, 22, 23, 18, 19, 21, 26, 27, 29, 3, 4, 11,
			12, 15, 16, 22, 23, 30, 31, };

	private static final boolean jjCanMove_0(int hiByte, int i1, int i2,
			long l1, long l2) {
		switch (hiByte) {
		case 0:
			return ((jjbitVec2[i2] & l2) != 0L);
		default:
			if ((jjbitVec0[i1] & l1) != 0L)
				return true;
			return false;
		}
	}

	private static final boolean jjCanMove_1(int hiByte, int i1, int i2,
			long l1, long l2) {
		switch (hiByte) {
		case 0:
			return ((jjbitVec4[i2] & l2) != 0L);
		case 48:
			return ((jjbitVec5[i2] & l2) != 0L);
		case 49:
			return ((jjbitVec6[i2] & l2) != 0L);
		case 51:
			return ((jjbitVec7[i2] & l2) != 0L);
		case 61:
			return ((jjbitVec8[i2] & l2) != 0L);
		default:
			if ((jjbitVec3[i1] & l1) != 0L)
				return true;
			return false;
		}
	}

	public static final String[] jjstrLiteralImages = { "", null, "\44\173",
			"\43\173", null, null, null, null, null, null, null, null, null,
			null, "\164\162\165\145", "\146\141\154\163\145",
			"\156\165\154\154", "\175", "\56", "\50", "\51", "\133", "\135",
			"\72", "\54", "\76", "\147\164", "\74", "\154\164", "\76\75",
			"\147\145", "\74\75", "\154\145", "\75\75", "\145\161", "\41\75",
			"\156\145", "\41", "\156\157\164", "\46\46", "\141\156\144",
			"\174\174", "\157\162", "\145\155\160\164\171",
			"\151\156\163\164\141\156\143\145\157\146", "\52", "\53", "\55",
			"\77", "\57", "\144\151\166", "\45", "\155\157\144", null, null,
			null, null, null, null, null, };

	public static final String[] lexStateNames = { "DEFAULT", "IN_EXPRESSION", };

	public static final int[] jjnewLexState = { -1, -1, 1, 1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, };

	static final long[] jjtoToken = { 0x8fffffffffff60fL, };

	static final long[] jjtoSkip = { 0x1f0L, };

	protected SimpleCharStream input_stream;

	private final int[] jjrounds = new int[41];

	private final int[] jjstateSet = new int[82];

	protected char curChar;

	public ELParserTokenManager(SimpleCharStream stream) {
		if (SimpleCharStream.staticFlag)
			throw new Error(
					"ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
		input_stream = stream;
	}

	public ELParserTokenManager(SimpleCharStream stream, int lexState) {
		this(stream);
		SwitchTo(lexState);
	}

	public void ReInit(SimpleCharStream stream) {
		jjmatchedPos = jjnewStateCnt = 0;
		curLexState = defaultLexState;
		input_stream = stream;
		ReInitRounds();
	}

	private final void ReInitRounds() {
		int i;
		jjround = 0x80000001;
		for (i = 41; i-- > 0;)
			jjrounds[i] = 0x80000000;
	}

	public void ReInit(SimpleCharStream stream, int lexState) {
		ReInit(stream);
		SwitchTo(lexState);
	}

	public void SwitchTo(int lexState) {
		if (lexState >= 2 || lexState < 0)
			throw new TokenMgrError("Error: Ignoring invalid lexical state : "
					+ lexState + ". State unchanged.",
					TokenMgrError.INVALID_LEXICAL_STATE);
		else
			curLexState = lexState;
	}

	protected Token jjFillToken() {
		Token t = Token.newToken(jjmatchedKind);
		t.kind = jjmatchedKind;
		String im = jjstrLiteralImages[jjmatchedKind];
		t.image = (im == null) ? input_stream.GetImage() : im;
		t.beginLine = input_stream.getBeginLine();
		t.beginColumn = input_stream.getBeginColumn();
		t.endLine = input_stream.getEndLine();
		t.endColumn = input_stream.getEndColumn();
		return t;
	}

	int curLexState = 0;

	int defaultLexState = 0;

	int jjnewStateCnt;

	int jjround;

	int jjmatchedPos;

	int jjmatchedKind;

	public Token getNextToken() {
		int kind;
		Token specialToken = null;
		Token matchedToken;
		int curPos = 0;

		EOFLoop: for (;;) {
			try {
				curChar = input_stream.BeginToken();
			} catch (java.io.IOException e) {
				jjmatchedKind = 0;
				matchedToken = jjFillToken();
				return matchedToken;
			}

			switch (curLexState) {
			case 0:
				jjmatchedKind = 0x7fffffff;
				jjmatchedPos = 0;
				curPos = jjMoveStringLiteralDfa0_0();
				break;
			case 1:
				try {
					input_stream.backup(0);
					while (curChar <= 32
							&& (0x100002600L & (1L << curChar)) != 0L)
						curChar = input_stream.BeginToken();
				} catch (java.io.IOException e1) {
					continue EOFLoop;
				}
				jjmatchedKind = 0x7fffffff;
				jjmatchedPos = 0;
				curPos = jjMoveStringLiteralDfa0_1();
				if (jjmatchedPos == 0 && jjmatchedKind > 59) {
					jjmatchedKind = 59;
				}
				break;
			}
			if (jjmatchedKind != 0x7fffffff) {
				if (jjmatchedPos + 1 < curPos)
					input_stream.backup(curPos - jjmatchedPos - 1);
				if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
					matchedToken = jjFillToken();
					if (jjnewLexState[jjmatchedKind] != -1)
						curLexState = jjnewLexState[jjmatchedKind];
					return matchedToken;
				} else {
					if (jjnewLexState[jjmatchedKind] != -1)
						curLexState = jjnewLexState[jjmatchedKind];
					continue EOFLoop;
				}
			}
			int error_line = input_stream.getEndLine();
			int error_column = input_stream.getEndColumn();
			String error_after = null;
			boolean EOFSeen = false;
			try {
				input_stream.readChar();
				input_stream.backup(1);
			} catch (java.io.IOException e1) {
				EOFSeen = true;
				error_after = curPos <= 1 ? "" : input_stream.GetImage();
				if (curChar == '\n' || curChar == '\r') {
					error_line++;
					error_column = 0;
				} else
					error_column++;
			}
			if (!EOFSeen) {
				input_stream.backup(1);
				error_after = curPos <= 1 ? "" : input_stream.GetImage();
			}
			throw new TokenMgrError(EOFSeen, curLexState, error_line,
					error_column, error_after, curChar,
					TokenMgrError.LEXICAL_ERROR);
		}
	}

}





public interface ELParserConstants {

  int EOF = 0;
  int LITERAL_EXPRESSION = 1;
  int START_DYNAMIC_EXPRESSION = 2;
  int START_DEFERRED_EXPRESSION = 3;
  int INTEGER_LITERAL = 9;
  int FLOATING_POINT_LITERAL = 10;
  int EXPONENT = 11;
  int STRING_LITERAL = 12;
  int BADLY_ESCAPED_STRING_LITERAL = 13;
  int TRUE = 14;
  int FALSE = 15;
  int NULL = 16;
  int END_EXPRESSION = 17;
  int DOT = 18;
  int LPAREN = 19;
  int RPAREN = 20;
  int LBRACK = 21;
  int RBRACK = 22;
  int COLON = 23;
  int COMMA = 24;
  int GT0 = 25;
  int GT1 = 26;
  int LT0 = 27;
  int LT1 = 28;
  int GE0 = 29;
  int GE1 = 30;
  int LE0 = 31;
  int LE1 = 32;
  int EQ0 = 33;
  int EQ1 = 34;
  int NE0 = 35;
  int NE1 = 36;
  int NOT0 = 37;
  int NOT1 = 38;
  int AND0 = 39;
  int AND1 = 40;
  int OR0 = 41;
  int OR1 = 42;
  int EMPTY = 43;
  int INSTANCEOF = 44;
  int MULT = 45;
  int PLUS = 46;
  int MINUS = 47;
  int QUESTIONMARK = 48;
  int DIV0 = 49;
  int DIV1 = 50;
  int MOD0 = 51;
  int MOD1 = 52;
  int IDENTIFIER = 53;
  int NAMESPACE = 54;
  int NAMESPACE_NAME = 55;
  int FUNCTION_CALL = 56;
  int FUNCTIONSUFFIX = 57;
  int IMPL_OBJ_START = 58;
  int LETTER = 59;
  int DIGIT = 60;
  int ILLEGAL_CHARACTER = 61;

  int DEFAULT = 0;
  int IN_EXPRESSION = 1;

  String[] tokenImage = {
    "<EOF>",
    "<LITERAL_EXPRESSION>",
    "\"${\"",
    "\"#{\"",
    "\"\\\\\"",
    "\" \"",
    "\"\\t\"",
    "\"\\n\"",
    "\"\\r\"",
    "<INTEGER_LITERAL>",
    "<FLOATING_POINT_LITERAL>",
    "<EXPONENT>",
    "<STRING_LITERAL>",
    "<BADLY_ESCAPED_STRING_LITERAL>",
    "\"true\"",
    "\"false\"",
    "\"null\"",
    "\"}\"",
    "\".\"",
    "\"(\"",
    "\")\"",
    "\"[\"",
    "\"]\"",
    "\":\"",
    "\",\"",
    "\">\"",
    "\"gt\"",
    "\"<\"",
    "\"lt\"",
    "\">=\"",
    "\"ge\"",
    "\"<=\"",
    "\"le\"",
    "\"==\"",
    "\"eq\"",
    "\"!=\"",
    "\"ne\"",
    "\"!\"",
    "\"not\"",
    "\"&&\"",
    "\"and\"",
    "\"||\"",
    "\"or\"",
    "\"empty\"",
    "\"instanceof\"",
    "\"*\"",
    "\"+\"",
    "\"-\"",
    "\"?\"",
    "\"/\"",
    "\"div\"",
    "\"%\"",
    "\"mod\"",
    "<IDENTIFIER>",
    "<NAMESPACE>",
    "<NAMESPACE_NAME>",
    "<FUNCTION_CALL>",
    "<FUNCTIONSUFFIX>",
    "\"#\"",
    "<LETTER>",
    "<DIGIT>",
    "<ILLEGAL_CHARACTER>",
  };

	int START_DEFERRED_EXPRESSION = 3;

	int INTEGER_LITERAL = 9;

	int FLOATING_POINT_LITERAL = 10;

	int EXPONENT = 11;

	int STRING_LITERAL = 12;

	int BADLY_ESCAPED_STRING_LITERAL = 13;

	int TRUE = 14;

	int FALSE = 15;

	int NULL = 16;

	int END_EXPRESSION = 17;

	int DOT = 18;

	int LPAREN = 19;

	int RPAREN = 20;

	int LBRACK = 21;

	int RBRACK = 22;

	int COLON = 23;

	int COMMA = 24;

	int GT0 = 25;

	int GT1 = 26;

	int LT0 = 27;

	int LT1 = 28;

	int GE0 = 29;

	int GE1 = 30;

	int LE0 = 31;

	int LE1 = 32;

	int EQ0 = 33;

	int EQ1 = 34;

	int NE0 = 35;

	int NE1 = 36;

	int NOT0 = 37;

	int NOT1 = 38;

	int AND0 = 39;

	int AND1 = 40;

	int OR0 = 41;

	int OR1 = 42;

	int EMPTY = 43;

	int INSTANCEOF = 44;

	int MULT = 45;

	int PLUS = 46;

	int MINUS = 47;

	int QUESTIONMARK = 48;

	int DIV0 = 49;

	int DIV1 = 50;

	int MOD0 = 51;

	int MOD1 = 52;

	int IDENTIFIER = 53;

	int NAMESPACE = 54;

	int FUNCTIONSUFFIX = 55;

	int IMPL_OBJ_START = 56;

	int LETTER = 57;

	int DIGIT = 58;

	int ILLEGAL_CHARACTER = 59;

	int DEFAULT = 0;

	int IN_EXPRESSION = 1;

	String[] tokenImage = { "<EOF>", "<LITERAL_EXPRESSION>", "\"${\"",
			"\"#{\"", "\"\\\\\"", "\" \"", "\"\\t\"", "\"\\n\"", "\"\\r\"",
			"<INTEGER_LITERAL>", "<FLOATING_POINT_LITERAL>", "<EXPONENT>",
			"<STRING_LITERAL>", "<BADLY_ESCAPED_STRING_LITERAL>", "\"true\"",
			"\"false\"", "\"null\"", "\"}\"", "\".\"", "\"(\"", "\")\"",
			"\"[\"", "\"]\"", "\":\"", "\",\"", "\">\"", "\"gt\"", "\"<\"",
			"\"lt\"", "\">=\"", "\"ge\"", "\"<=\"", "\"le\"", "\"==\"",
			"\"eq\"", "\"!=\"", "\"ne\"", "\"!\"", "\"not\"", "\"&&\"",
			"\"and\"", "\"||\"", "\"or\"", "\"empty\"", "\"instanceof\"",
			"\"*\"", "\"+\"", "\"-\"", "\"?\"", "\"/\"", "\"div\"", "\"%\"",
			"\"mod\"", "<IDENTIFIER>", "<NAMESPACE>", "<FUNCTIONSUFFIX>",
			"\"#\"", "<LETTER>", "<DIGIT>", "<ILLEGAL_CHARACTER>", };

}




import javax.el.ELException;
public class ELParser/*@bgen(jjtree)*/implements ELParserTreeConstants, ELParserConstants {/*@bgen(jjtree)*/
  protected JJTELParserState jjtree = new JJTELParserState();public static Node parse(String ref) throws ELException
   {
       try {
               return (new ELParser(new StringReader(ref))).CompositeExpression();
       } catch (ParseException pe) {
               throw new ELException(pe.getMessage());
       }
   }

  public static void main(String[] argv) throws Exception {
	  String[] str = { "${foo()}", "${fn.fn:foo() ? a : b}", "${fn.2fn:foo() ? a : b}", "${fn:foo() ? (fn_af.f:fd() ? a : b) : b}", "${a.b.c ? a : b}", "${true?false:true}", "${true? (false?true:false):false}" };
		for (int i = 0; i < str.length; i++) {
			SimpleNode sn = (SimpleNode) ELParser.parse(str[i]);
			System.out.println("====\n" + str[i]);

        }
      }
      jj_consume_token(0);
                                                                                   jjtree.closeNodeScope(jjtn000, true);
                                                                                   jjtc000 = false;
                                                                                   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
    throw new Error("Missing return statement in function");
  }

                                                jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(LITERAL_EXPRESSION);
                                jjtree.closeNodeScope(jjtn000, true);
                                jjtc000 = false;
                                jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


      Expression();
      jj_consume_token(END_EXPRESSION);
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


      Expression();
      jj_consume_token(END_EXPRESSION);
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


      jj_consume_token(QUESTIONMARK);
      Or();
      jj_consume_token(COLON);
                                           AstChoice jjtn001 = new AstChoice(JJTCHOICE);
                                           boolean jjtc001 = true;
                                           jjtree.openNodeScope(jjtn001);
      try {
        Choice();
      } catch (Throwable jjte001) {
                                           if (jjtc001) {
                                             jjtree.clearNodeScope(jjtn001);
                                             jjtc001 = false;
                                           } else {
                                             jjtree.popNode();
                                           }
                                           if (jjte001 instanceof RuntimeException) {
                                             {if (true) throw (RuntimeException)jjte001;}
                                           }
                                           if (jjte001 instanceof ParseException) {
                                             {if (true) throw (ParseException)jjte001;}
                                           }
                                           {if (true) throw (Error)jjte001;}
      } finally {
                                           if (jjtc001) {
                                             jjtree.closeNodeScope(jjtn001,  3);
                                           }
      }
    }
  }

        jj_consume_token(-1);
        throw new ParseException();
      }
                              AstOr jjtn001 = new AstOr(JJTOR);
                              boolean jjtc001 = true;
                              jjtree.openNodeScope(jjtn001);
      try {
        And();
      } catch (Throwable jjte001) {
                              if (jjtc001) {
                                jjtree.clearNodeScope(jjtn001);
                                jjtc001 = false;
                              } else {
                                jjtree.popNode();
                              }
                              if (jjte001 instanceof RuntimeException) {
                                {if (true) throw (RuntimeException)jjte001;}
                              }
                              if (jjte001 instanceof ParseException) {
                                {if (true) throw (ParseException)jjte001;}
                              }
                              {if (true) throw (Error)jjte001;}
      } finally {
                              if (jjtc001) {
                                jjtree.closeNodeScope(jjtn001,  2);
                              }
      }
    }
  }

        jj_consume_token(-1);
        throw new ParseException();
      }
                                     AstAnd jjtn001 = new AstAnd(JJTAND);
                                     boolean jjtc001 = true;
                                     jjtree.openNodeScope(jjtn001);
      try {
        Equality();
      } catch (Throwable jjte001) {
                                     if (jjtc001) {
                                       jjtree.clearNodeScope(jjtn001);
                                       jjtc001 = false;
                                     } else {
                                       jjtree.popNode();
                                     }
                                     if (jjte001 instanceof RuntimeException) {
                                       {if (true) throw (RuntimeException)jjte001;}
                                     }
                                     if (jjte001 instanceof ParseException) {
                                       {if (true) throw (ParseException)jjte001;}
                                     }
                                     {if (true) throw (Error)jjte001;}
      } finally {
                                     if (jjtc001) {
                                       jjtree.closeNodeScope(jjtn001,  2);
                                     }
      }
    }
  }

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstEqual jjtn001 = new AstEqual(JJTEQUAL);
                                boolean jjtc001 = true;
                                jjtree.openNodeScope(jjtn001);
        try {
          Compare();
        } catch (Throwable jjte001) {
                                if (jjtc001) {
                                  jjtree.clearNodeScope(jjtn001);
                                  jjtc001 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte001 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte001;}
                                }
                                if (jjte001 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte001;}
                                }
                                {if (true) throw (Error)jjte001;}
        } finally {
                                if (jjtc001) {
                                  jjtree.closeNodeScope(jjtn001,  2);
                                }
        }
        break;
      case NE0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstNotEqual jjtn002 = new AstNotEqual(JJTNOTEQUAL);
                                boolean jjtc002 = true;
                                jjtree.openNodeScope(jjtn002);
        try {
          Compare();
        } catch (Throwable jjte002) {
                                if (jjtc002) {
                                  jjtree.clearNodeScope(jjtn002);
                                  jjtc002 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte002 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte002;}
                                }
                                if (jjte002 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte002;}
                                }
                                {if (true) throw (Error)jjte002;}
        } finally {
                                if (jjtc002) {
                                  jjtree.closeNodeScope(jjtn002,  2);
                                }
        }
        break;
      default:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstLessThan jjtn001 = new AstLessThan(JJTLESSTHAN);
                                boolean jjtc001 = true;
                                jjtree.openNodeScope(jjtn001);
        try {
          Math();
        } catch (Throwable jjte001) {
                                if (jjtc001) {
                                  jjtree.clearNodeScope(jjtn001);
                                  jjtc001 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte001 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte001;}
                                }
                                if (jjte001 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte001;}
                                }
                                {if (true) throw (Error)jjte001;}
        } finally {
                                if (jjtc001) {
                                  jjtree.closeNodeScope(jjtn001,  2);
                                }
        }
        break;
      case GT0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstGreaterThan jjtn002 = new AstGreaterThan(JJTGREATERTHAN);
                                boolean jjtc002 = true;
                                jjtree.openNodeScope(jjtn002);
        try {
          Math();
        } catch (Throwable jjte002) {
                                if (jjtc002) {
                                  jjtree.clearNodeScope(jjtn002);
                                  jjtc002 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte002 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte002;}
                                }
                                if (jjte002 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte002;}
                                }
                                {if (true) throw (Error)jjte002;}
        } finally {
                                if (jjtc002) {
                                  jjtree.closeNodeScope(jjtn002,  2);
                                }
        }
        break;
      case LE0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstLessThanEqual jjtn003 = new AstLessThanEqual(JJTLESSTHANEQUAL);
                                boolean jjtc003 = true;
                                jjtree.openNodeScope(jjtn003);
        try {
          Math();
        } catch (Throwable jjte003) {
                                if (jjtc003) {
                                  jjtree.clearNodeScope(jjtn003);
                                  jjtc003 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte003 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte003;}
                                }
                                if (jjte003 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte003;}
                                }
                                {if (true) throw (Error)jjte003;}
        } finally {
                                if (jjtc003) {
                                  jjtree.closeNodeScope(jjtn003,  2);
                                }
        }
        break;
      case GE0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                AstGreaterThanEqual jjtn004 = new AstGreaterThanEqual(JJTGREATERTHANEQUAL);
                                boolean jjtc004 = true;
                                jjtree.openNodeScope(jjtn004);
        try {
          Math();
        } catch (Throwable jjte004) {
                                if (jjtc004) {
                                  jjtree.clearNodeScope(jjtn004);
                                  jjtc004 = false;
                                } else {
                                  jjtree.popNode();
                                }
                                if (jjte004 instanceof RuntimeException) {
                                  {if (true) throw (RuntimeException)jjte004;}
                                }
                                if (jjte004 instanceof ParseException) {
                                  {if (true) throw (ParseException)jjte004;}
                                }
                                {if (true) throw (Error)jjte004;}
        } finally {
                                if (jjtc004) {
                                  jjtree.closeNodeScope(jjtn004,  2);
                                }
        }
        break;
      default:

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        jj_consume_token(PLUS);
                         AstPlus jjtn001 = new AstPlus(JJTPLUS);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
        try {
          Multiplication();
        } catch (Throwable jjte001) {
                         if (jjtc001) {
                           jjtree.clearNodeScope(jjtn001);
                           jjtc001 = false;
                         } else {
                           jjtree.popNode();
                         }
                         if (jjte001 instanceof RuntimeException) {
                           {if (true) throw (RuntimeException)jjte001;}
                         }
                         if (jjte001 instanceof ParseException) {
                           {if (true) throw (ParseException)jjte001;}
                         }
                         {if (true) throw (Error)jjte001;}
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  2);
                         }
        }
        break;
      case MINUS:
        jj_consume_token(MINUS);
                          AstMinus jjtn002 = new AstMinus(JJTMINUS);
                          boolean jjtc002 = true;
                          jjtree.openNodeScope(jjtn002);
        try {
          Multiplication();
        } catch (Throwable jjte002) {
                          if (jjtc002) {
                            jjtree.clearNodeScope(jjtn002);
                            jjtc002 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte002 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte002;}
                          }
                          if (jjte002 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte002;}
                          }
                          {if (true) throw (Error)jjte002;}
        } finally {
                          if (jjtc002) {
                            jjtree.closeNodeScope(jjtn002,  2);
                          }
        }
        break;
      default:

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MULT:
        jj_consume_token(MULT);
                         AstMult jjtn001 = new AstMult(JJTMULT);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
        try {
          Unary();
        } catch (Throwable jjte001) {
                         if (jjtc001) {
                           jjtree.clearNodeScope(jjtn001);
                           jjtc001 = false;
                         } else {
                           jjtree.popNode();
                         }
                         if (jjte001 instanceof RuntimeException) {
                           {if (true) throw (RuntimeException)jjte001;}
                         }
                         if (jjte001 instanceof ParseException) {
                           {if (true) throw (ParseException)jjte001;}
                         }
                         {if (true) throw (Error)jjte001;}
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  2);
                         }
        }
        break;
      case DIV0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                  AstDiv jjtn002 = new AstDiv(JJTDIV);
                                  boolean jjtc002 = true;
                                  jjtree.openNodeScope(jjtn002);
        try {
          Unary();
        } catch (Throwable jjte002) {
                                  if (jjtc002) {
                                    jjtree.clearNodeScope(jjtn002);
                                    jjtc002 = false;
                                  } else {
                                    jjtree.popNode();
                                  }
                                  if (jjte002 instanceof RuntimeException) {
                                    {if (true) throw (RuntimeException)jjte002;}
                                  }
                                  if (jjte002 instanceof ParseException) {
                                    {if (true) throw (ParseException)jjte002;}
                                  }
                                  {if (true) throw (Error)jjte002;}
        } finally {
                                  if (jjtc002) {
                                    jjtree.closeNodeScope(jjtn002,  2);
                                  }
        }
        break;
      case MOD0:

          jj_consume_token(-1);
          throw new ParseException();
        }
                                  AstMod jjtn003 = new AstMod(JJTMOD);
                                  boolean jjtc003 = true;
                                  jjtree.openNodeScope(jjtn003);
        try {
          Unary();
        } catch (Throwable jjte003) {
                                  if (jjtc003) {
                                    jjtree.clearNodeScope(jjtn003);
                                    jjtc003 = false;
                                  } else {
                                    jjtree.popNode();
                                  }
                                  if (jjte003 instanceof RuntimeException) {
                                    {if (true) throw (RuntimeException)jjte003;}
                                  }
                                  if (jjte003 instanceof ParseException) {
                                    {if (true) throw (ParseException)jjte003;}
                                  }
                                  {if (true) throw (Error)jjte003;}
        } finally {
                                  if (jjtc003) {
                                    jjtree.closeNodeScope(jjtn003,  2);
                                  }
        }
        break;
      default:

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case MINUS:
      jj_consume_token(MINUS);
                         AstNegative jjtn001 = new AstNegative(JJTNEGATIVE);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
      try {
        Unary();
      } catch (Throwable jjte001) {
                         if (jjtc001) {
                           jjtree.clearNodeScope(jjtn001);
                           jjtc001 = false;
                         } else {
                           jjtree.popNode();
                         }
                         if (jjte001 instanceof RuntimeException) {
                           {if (true) throw (RuntimeException)jjte001;}
                         }
                         if (jjte001 instanceof ParseException) {
                           {if (true) throw (ParseException)jjte001;}
                         }
                         {if (true) throw (Error)jjte001;}
      } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001, true);
                         }
      }
      break;
    case NOT0:

        jj_consume_token(-1);
        throw new ParseException();
      }
                                 AstNot jjtn002 = new AstNot(JJTNOT);
                                 boolean jjtc002 = true;
                                 jjtree.openNodeScope(jjtn002);
      try {
        Unary();
      } catch (Throwable jjte002) {
                                 if (jjtc002) {
                                   jjtree.clearNodeScope(jjtn002);
                                   jjtc002 = false;
                                 } else {
                                   jjtree.popNode();
                                 }
                                 if (jjte002 instanceof RuntimeException) {
                                   {if (true) throw (RuntimeException)jjte002;}
                                 }
                                 if (jjte002 instanceof ParseException) {
                                   {if (true) throw (ParseException)jjte002;}
                                 }
                                 {if (true) throw (Error)jjte002;}
      } finally {
                                 if (jjtc002) {
                                   jjtree.closeNodeScope(jjtn002, true);
                                 }
      }
      break;
    case EMPTY:
      jj_consume_token(EMPTY);
                         AstEmpty jjtn003 = new AstEmpty(JJTEMPTY);
                         boolean jjtc003 = true;
                         jjtree.openNodeScope(jjtn003);
      try {
        Unary();
      } catch (Throwable jjte003) {
                         if (jjtc003) {
                           jjtree.clearNodeScope(jjtn003);
                           jjtc003 = false;
                         } else {
                           jjtree.popNode();
                         }
                         if (jjte003 instanceof RuntimeException) {
                           {if (true) throw (RuntimeException)jjte003;}
                         }
                         if (jjte003 instanceof ParseException) {
                           {if (true) throw (ParseException)jjte003;}
                         }
                         {if (true) throw (Error)jjte003;}
      } finally {
                         if (jjtc003) {
                           jjtree.closeNodeScope(jjtn003, true);
                         }
      }
      break;
    case INTEGER_LITERAL:

    case NULL:
    case LPAREN:
    case IDENTIFIER:
    case FUNCTION_CALL:
      Value();
      break;
    default:

 * Defines Prefix plus zero or more Suffixes
 */
  final public void Value() throws ParseException {
         AstValue jjtn001 = new AstValue(JJTVALUE);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
    try {
      ValuePrefix();
      label_9:

        ValueSuffix();
      }
    } catch (Throwable jjte001) {
         if (jjtc001) {
           jjtree.clearNodeScope(jjtn001);
           jjtc001 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte001 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte001;}
         }
         if (jjte001 instanceof ParseException) {
           {if (true) throw (ParseException)jjte001;}
         }
         {if (true) throw (Error)jjte001;}
    } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
         }
    }
  }


      break;
    case LPAREN:
    case IDENTIFIER:
    case FUNCTION_CALL:
      NonLiteral();
      break;
    default:

    try {
      jj_consume_token(DOT);
      t = jj_consume_token(IDENTIFIER);
                              jjtree.closeNodeScope(jjtn000, true);
                              jjtc000 = false;
                              jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


      Expression();
      jj_consume_token(RBRACK);
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


                                  jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(IDENTIFIER);
                        jjtree.closeNodeScope(jjtn000, true);
                        jjtc000 = false;
                        jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


 */
  final public void Function() throws ParseException {
 /*@bgen(jjtree) Function */
       AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);Token tx = null;
        Token t1 = null;
    try {
      tx = jj_consume_token(FUNCTION_CALL);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NAMESPACE:
        t0 = jj_consume_token(NAMESPACE);
        break;
      default:
        jj_la1[30] = jj_gen;
        ;
      }
      t1 = jj_consume_token(IDENTIFIER);
                if (t0 != null) {
                        jjtn000.setPrefix(t0.image.substring(0, t0.image.length() - 1));
                        jjtn000.setLocalName(t1.image);
                } else {
                        jjtn000.setLocalName(t1.image);
                }
      jj_consume_token(LPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case STRING_LITERAL:

      case EMPTY:
      case MINUS:
      case IDENTIFIER:
      case FUNCTION_CALL:
        Expression();
        label_10:
        while (true) {

            ;
            break;
          default:
            jj_la1[30] = jj_gen;
            break label_10;
          }
          jj_consume_token(COMMA);

        }
        break;
      default:
        jj_la1[31] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
         jjtree.closeNodeScope(jjtn000, true);
         jjtc000 = false;
               if (tx.image.indexOf(":")!=-1) {
                       jjtn000.setPrefix(tx.image.substring(0, tx.image.indexOf(":")));
                       jjtn000.setLocalName(tx.image.substring(tx.image.indexOf(":") + 1, tx.image.length() - 1));
               } else {
                       jjtn000.setLocalName(tx.image.substring(0, tx.image.length() - 1));
               }
    } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
         }
         if (jjte000 instanceof RuntimeException) {
           {if (true) throw (RuntimeException)jjte000;}
         }
         if (jjte000 instanceof ParseException) {
           {if (true) throw (ParseException)jjte000;}
         }
         {if (true) throw (Error)jjte000;}
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


      Null();
      break;
    default:
      jj_la1[32] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

  final public void Boolean() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TRUE:
         AstTrue jjtn001 = new AstTrue(JJTTRUE);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
      try {
        jj_consume_token(TRUE);
      } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001, true);
         }
      }
      break;
    case FALSE:
           AstFalse jjtn002 = new AstFalse(JJTFALSE);
           boolean jjtc002 = true;
           jjtree.openNodeScope(jjtn002);
      try {
        jj_consume_token(FALSE);
      } finally {
           if (jjtc002) {
             jjtree.closeNodeScope(jjtn002, true);
           }
      }
      break;
    default:
      jj_la1[33] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

                                        jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(FLOATING_POINT_LITERAL);
                                    jjtree.closeNodeScope(jjtn000, true);
                                    jjtc000 = false;
                                    jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


                            jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(INTEGER_LITERAL);
                             jjtree.closeNodeScope(jjtn000, true);
                             jjtc000 = false;
                             jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


                          jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(STRING_LITERAL);
                            jjtree.closeNodeScope(jjtn000, true);
                            jjtc000 = false;
                            jjtn000.setImage(t.image);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


    try {
      jj_consume_token(NULL);
    } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
         }
    }
  }


  }

  final private boolean jj_3R_11() {
    if (jj_scan_token(FUNCTION_CALL)) return true;
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(54)) jj_scanpos = xsp;
    if (jj_scan_token(IDENTIFIER)) return true;
    if (jj_scan_token(LPAREN)) return true;
    xsp = jj_scanpos;
    if (jj_3R_12()) jj_scanpos = xsp;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  final private boolean jj_3R_28() {
    if (jj_3R_34()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_35()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_37() {
    if (jj_scan_token(MINUS)) return true;
    return false;
  }

  final private boolean jj_3R_29() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_36()) {
    jj_scanpos = xsp;
    if (jj_3R_37()) return true;
    }
    return false;
  }

  final private boolean jj_3R_36() {
    if (jj_scan_token(PLUS)) return true;
    return false;
  }

  final private boolean jj_3R_69() {
    if (jj_scan_token(IDENTIFIER)) return true;
    return false;
  }

  final private boolean jj_3R_61() {
    if (jj_3R_69()) return true;
    return false;
  }

  final private boolean jj_3R_24() {
    if (jj_3R_28()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_29()) { jj_scanpos = xsp; break; }
    }
    return false;
  }


    return false;
  }

  final private boolean jj_3R_33() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(29)) {
    jj_scanpos = xsp;
    if (jj_scan_token(30)) return true;
    }
    return false;
  }

  final private boolean jj_3R_60() {
    if (jj_scan_token(LPAREN)) return true;
    if (jj_3R_13()) return true;
    return false;
  }

  final private boolean jj_3R_52() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_60()) {
    jj_scanpos = xsp;
    if (jj_3_1()) {
    jj_scanpos = xsp;
    if (jj_3R_61()) return true;
    }
    }
    return false;
  }

  final private boolean jj_3R_32() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(31)) {
    jj_scanpos = xsp;
    if (jj_scan_token(32)) return true;
    }
    return false;
  }

  final private boolean jj_3R_31() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(25)) {
    jj_scanpos = xsp;
    if (jj_scan_token(26)) return true;
    }
    return false;
  }

  final private boolean jj_3R_25() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_30()) {
    jj_scanpos = xsp;
    if (jj_3R_31()) {
    jj_scanpos = xsp;
    if (jj_3R_32()) {
    jj_scanpos = xsp;
    if (jj_3R_33()) return true;
    }
    }
    }
    return false;
  }

  final private boolean jj_3R_30() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(27)) {
    jj_scanpos = xsp;
    if (jj_scan_token(28)) return true;
    }
    return false;
  }

  final private boolean jj_3R_68() {
    if (jj_scan_token(NULL)) return true;
    return false;
  }

  final private boolean jj_3R_63() {
    if (jj_scan_token(LBRACK)) return true;
    return false;
  }

  final private boolean jj_3R_54() {
    if (jj_3R_63()) return true;
    return false;
  }

  final private boolean jj_3R_67() {
    if (jj_scan_token(STRING_LITERAL)) return true;
    return false;
  }

  final private boolean jj_3R_22() {
    if (jj_3R_24()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_25()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_27() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(35)) {
    jj_scanpos = xsp;
    if (jj_scan_token(36)) return true;
    }
    return false;
  }

  final private boolean jj_3R_62() {
    if (jj_scan_token(DOT)) return true;
    return false;
  }

  final private boolean jj_3R_26() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(33)) {
    jj_scanpos = xsp;
    if (jj_scan_token(34)) return true;
    }
    return false;
  }

  final private boolean jj_3R_23() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_26()) {
    jj_scanpos = xsp;
    if (jj_3R_27()) return true;
    }
    return false;
  }

  final private boolean jj_3R_66() {
    if (jj_scan_token(INTEGER_LITERAL)) return true;
    return false;
  }

  final private boolean jj_3R_21() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(39)) {
    jj_scanpos = xsp;
    if (jj_scan_token(40)) return true;
    }
    return false;
  }

  final private boolean jj_3R_53() {
    if (jj_3R_62()) return true;
    return false;
  }

  final private boolean jj_3R_50() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_53()) {
    jj_scanpos = xsp;
    if (jj_3R_54()) return true;
    }
    return false;
  }

  final private boolean jj_3R_20() {
    if (jj_3R_22()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_23()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_47() {
    if (jj_3R_50()) return true;
    return false;
  }

  final private boolean jj_3R_65() {
    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
    return false;
  }

  final private boolean jj_3R_49() {
    if (jj_3R_52()) return true;
    return false;
  }

  final private boolean jj_3R_14() {
    if (jj_scan_token(COMMA)) return true;
    return false;
  }

  final private boolean jj_3R_48() {
    if (jj_3R_51()) return true;
    return false;
  }

  final private boolean jj_3R_46() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_48()) {
    jj_scanpos = xsp;
    if (jj_3R_49()) return true;
    }
    return false;
  }

  final private boolean jj_3R_18() {
    if (jj_3R_20()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_21()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_71() {
    if (jj_scan_token(FALSE)) return true;
    return false;
  }

  final private boolean jj_3R_19() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(41)) {
    jj_scanpos = xsp;
    if (jj_scan_token(42)) return true;
    }
    return false;
  }

  final private boolean jj_3R_70() {
    if (jj_scan_token(TRUE)) return true;
    return false;
  }

  final private boolean jj_3R_64() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_70()) {
    jj_scanpos = xsp;
    if (jj_3R_71()) return true;
    }
    return false;
  }

  final private boolean jj_3R_45() {
    if (jj_3R_46()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_47()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_16() {
    if (jj_3R_18()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_19()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_41() {
    if (jj_3R_45()) return true;
    return false;
  }

  final private boolean jj_3R_59() {
    if (jj_3R_68()) return true;
    return false;
  }

  final private boolean jj_3R_17() {
    if (jj_scan_token(QUESTIONMARK)) return true;
    return false;
  }

  final private boolean jj_3R_40() {
    if (jj_scan_token(EMPTY)) return true;
    if (jj_3R_34()) return true;
    return false;
  }

  final private boolean jj_3R_12() {
    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_3R_58() {
    if (jj_3R_67()) return true;
    return false;
  }

  final private boolean jj_3R_57() {
    if (jj_3R_66()) return true;
    return false;
  }

  final private boolean jj_3R_39() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(37)) {
    jj_scanpos = xsp;
    if (jj_scan_token(38)) return true;
    }
    if (jj_3R_34()) return true;
    return false;
  }

  final private boolean jj_3R_56() {
    if (jj_3R_65()) return true;
    return false;
  }

  final private boolean jj_3R_34() {
    if (jj_scan_token(MINUS)) return true;
    return false;
  }

  final private boolean jj_3R_21() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_38()) {
    jj_scanpos = xsp;
    if (jj_3R_39()) {
    jj_scanpos = xsp;
    if (jj_3R_40()) {
    jj_scanpos = xsp;
    if (jj_3R_41()) return true;
    }
    }
    }
    return false;
  }

  final private boolean jj_3R_38() {
    if (jj_scan_token(MINUS)) return true;
    if (jj_3R_34()) return true;
    return false;
  }

  final private boolean jj_3R_55() {
    if (jj_3R_64()) return true;
    return false;
  }

  final private boolean jj_3R_51() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_55()) {
    jj_scanpos = xsp;
    if (jj_3R_56()) {
    jj_scanpos = xsp;
    if (jj_3R_57()) {
    jj_scanpos = xsp;
    if (jj_3R_58()) {
    jj_scanpos = xsp;
    if (jj_3R_59()) return true;
    }
    }
    }

    return false;
  }

  final private boolean jj_3R_15() {
    if (jj_3R_16()) return true;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_17()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  final private boolean jj_3R_44() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(51)) {
    jj_scanpos = xsp;
    if (jj_scan_token(52)) return true;
    }
    return false;
  }

  final private boolean jj_3R_13() {
    if (jj_3R_15()) return true;
    return false;
  }

  final private boolean jj_3R_43() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(49)) {
    jj_scanpos = xsp;
    if (jj_scan_token(50)) return true;
    }
    return false;
  }

  final private boolean jj_3R_35() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_42()) {
    jj_scanpos = xsp;
    if (jj_3R_43()) {
    jj_scanpos = xsp;
    if (jj_3R_44()) return true;
    }
    }
    return false;
  }

  final private boolean jj_3R_42() {
    if (jj_scan_token(MULT)) return true;
    return false;
  }

  public ELParserTokenManager token_source;
  SimpleCharStream jj_input_stream;
  public Token token, jj_nt;

  public boolean lookingAhead = false;
  private boolean jj_semLA;
  private int jj_gen;
  final private int[] jj_la1 = new int[34];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static {

      jj_la1_1();
   }
   private static void jj_la1_0() {
      jj_la1_0 = new int[] {0xe,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe000000,0x18000000,0x6000000,0x80000000,0x60000000,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9d600,0x240000,0x9d600,0x240000,0x80000,0x0,0x1000000,0x9d600,0x1d600,0xc000,};
   }
   private static void jj_la1_1() {
      jj_la1_1 = new int[] {0x0,0x0,0x10000,0x600,0x600,0x180,0x180,0x1e,0x6,0x18,0x1e,0x1,0x0,0x0,0x1,0x0,0x1,0xc000,0xc000,0x1e2000,0x60000,0x180000,0x1e2000,0x60,0x1208860,0x0,0x1200000,0x0,0x0,0x200000,0x0,0x1208860,0x0,0x0,};
   }
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
  private boolean jj_rescan = false;

    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }


    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }


    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }


    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }


    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }


    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }



  public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[62];
    for (int i = 0; i < 62; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 34; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {

        }
      }
    }
    for (int i = 0; i < 62; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;




 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 */

/*
       Author: Jacob Hookom
       Email:  jacob at hookom.net
*/

/* == Option Declaration == */
options
{
       STATIC=false;
       NODE_PREFIX="Ast";
       VISITOR_EXCEPTION="javax.el.ELException";
       VISITOR=false;
       MULTI=true;
       NODE_DEFAULT_VOID=true;
       JAVA_UNICODE_ESCAPE=false;
       UNICODE_INPUT=true;
       BUILD_NODE_FILES=false;
}

/* == Parser Declaration == */

import javax.el.ELException;
public class ELParser
{
   public static Node parse(String ref) throws ELException
   {
       try {
               return (new ELParser(new StringReader(ref))).CompositeExpression();
       } catch (ParseException pe) {
               throw new ELException(pe.getMessage());
       }
   }
}
PARSER_END( ELParser )


 */
AstCompositeExpression CompositeExpression() #CompositeExpression : {}
{
       (DeferredExpression() | DynamicExpression() | LiteralExpression())* <EOF> { return jjtThis; }
}

/*

 */
void LiteralExpression() #LiteralExpression : { Token t = null; }
{
       t=<LITERAL_EXPRESSION> { jjtThis.setImage(t.image); }
}

/*

 */
void DeferredExpression() #DeferredExpression : {}
{
       <START_DEFERRED_EXPRESSION> Expression() <END_EXPRESSION>
}

/*

 */
void DynamicExpression() #DynamicExpression : {}
{
       <START_DYNAMIC_EXPRESSION> Expression() <END_EXPRESSION>
}

/*

 */
void Expression() : {}
{
       Choice()
}

/*

 */
void Choice() : {}
{
       Or() (<QUESTIONMARK> Or() <COLON> Choice() #Choice(3))*
}

/*

 */
void Or() : {}
{
       And() ((<OR0>|<OR1>) And() #Or(2))*
}

/*

 */
void And() : {}
{
       Equality() ((<AND0>|<AND1>) Equality() #And(2))*
}

/*

 */
void Equality() : {}
{
       Compare()
       (
               ((<EQ0>|<EQ1>) Compare() #Equal(2))
       |
               ((<NE0>|<NE1>) Compare() #NotEqual(2))
       )*
}

/*

 */
void Compare() : {}
{
       Math()
       (
               ((<LT0>|<LT1>) Math() #LessThan(2))
       |
               ((<GT0>|<GT1>) Math() #GreaterThan(2))
       |
               ((<LE0>|<LE1>) Math() #LessThanEqual(2))
       |
               ((<GE0>|<GE1>) Math() #GreaterThanEqual(2))
       )*
}

/*

 */
void Math() : {}
{
       Multiplication()
       (
               (<PLUS> Multiplication() #Plus(2))
       |
               (<MINUS> Multiplication() #Minus(2))
       )*
}

/*

 */
void Multiplication() : {}
{
       Unary()
       (
               (<MULT> Unary() #Mult(2))
       |
               ((<DIV0>|<DIV1>) Unary() #Div(2))
       |
               ((<MOD0>|<MOD1>) Unary() #Mod(2))
       )*
}

/*

 */
void Unary() : {}
{
               <MINUS> Unary() #Negative
       |
               (<NOT0>|<NOT1>) Unary() #Not
       |
               <EMPTY> Unary() #Empty
       |
               Value()
}

/*

 */
void Value() : {}
{
       (ValuePrefix() (ValueSuffix())*) #Value(>1)
}

/*

 */
void ValuePrefix() : {}
{
       Literal()
       | NonLiteral()
}

/*

 */
void ValueSuffix() : {}
{
       DotSuffix() | BracketSuffix()
}

/*

 */
void DotSuffix() #DotSuffix : { Token t = null; }
{
       <DOT> t=<IDENTIFIER> { jjtThis.setImage(t.image); }
}

/*

 */
void BracketSuffix() #BracketSuffix : {}
{
       <LBRACK> Expression() <RBRACK>
}

/*

 */
void NonLiteral() : {}
{
       <LPAREN> Expression() <RPAREN>
       | LOOKAHEAD(3) Function()
       | Identifier()
}

/*

 */
void Identifier() #Identifier : { Token t = null; }
{
       t=<IDENTIFIER> { jjtThis.setImage(t.image); }
}

/*

 */
void Function() #Function :
{
       Token tx = null;
	Token t1 = null;
}
{
       (tx=<FUNCTION_CALL> ) (Expression() (<COMMA> Expression())*)? <RPAREN>
       {
               if (tx.image.indexOf(":")!=-1) {
                       jjtThis.setPrefix(tx.image.substring(0, tx.image.indexOf(":")));
                       jjtThis.setLocalName(tx.image.substring(tx.image.indexOf(":") + 1, tx.image.length() - 1));
               } else {
                       jjtThis.setLocalName(tx.image.substring(0, tx.image.length() - 1));
               }
       }
	<LPAREN> (Expression() (<COMMA> Expression())*)? <RPAREN>
}

/*

 */
void Literal() : {}
{
       Boolean()
       | FloatingPoint()
       | Integer()
       | String()
       | Null()
}

/*

 */
void Boolean() : {}
{
       <TRUE> #True
       | <FALSE> #False
}

/*

 */
void FloatingPoint() #FloatingPoint : { Token t = null; }
{
       t=<FLOATING_POINT_LITERAL> { jjtThis.setImage(t.image); }
}

/*

 */
void Integer() #Integer : { Token t = null; }
{
       t=<INTEGER_LITERAL> { jjtThis.setImage(t.image); }
}

/*

 */
void String() #String : { Token t = null; }
{
       t=<STRING_LITERAL> { jjtThis.setImage(t.image); }
}

/*

 */
void Null() #Null : {}
{
       <NULL>
}


/* ==================================================================================== */
<DEFAULT> TOKEN :
{
 < LITERAL_EXPRESSION:
   ((~["\\", "$", "#"])
     | ("\\" ("\\" | "$" | "#"))
     | ("$" ~["{", "$"])
     | ("#" ~["{", "#"])
   )+
   | "$"
   | "#"
 >
|
 < START_DYNAMIC_EXPRESSION: "${" > : IN_EXPRESSION
|
 < START_DEFERRED_EXPRESSION: "#{" > : IN_EXPRESSION
}

<DEFAULT> SKIP : { "\\" }


<IN_EXPRESSION> TOKEN :
{
       < 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: ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] )))
               | ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
       >
|       < TRUE : "true" >
|       < FALSE : "false" >
|       < NULL : "null" >
|       < END_EXPRESSION : "}" > : DEFAULT
|       < DOT : "." >
|       < LPAREN : "(" >
|       < RPAREN : ")" >
|       < LBRACK : "[" >
|       < RBRACK : "]" >
|       < COLON : ":" >
|       < COMMA : "," >
|       < GT0 : ">" >
|       < GT1 : "gt" >
|       < LT0 : "<" >
|       < LT1 : "lt" >
|       < GE0 : ">=" >
|       < GE1 : "ge" >
|       < LE0 : "<=" >
|       < LE1 : "le" >
|       < EQ0 : "==" >
|       < EQ1 : "eq" >
|       < NE0 : "!=" >
|       < NE1 : "ne" >
|       < NOT0 : "!" >
|       < NOT1 : "not" >
|       < AND0 : "&&" >
|       < AND1 : "and" >
|       < OR0 : "||" >
|       < OR1 : "or" >
|       < EMPTY : "empty" >
|       < INSTANCEOF : "instanceof" >
|       < MULT : "*" >
|       < PLUS : "+" >
|       < MINUS : "-" >
|       < QUESTIONMARK : "?" >
|       < DIV0 : "/" >
|       < DIV1 : "div" >
|       < MOD0 : "%" >
|       < MOD1 : "mod" >
|       < IDENTIFIER : (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
|   < #NAMESPACE : ( <NAMESPACE_NAME> <COLON>) >
|   < #NAMESPACE_NAME: (<IDENTIFIER> (<LETTER>|<DIGIT>|<MINUS>|<DOT>)*) >
|   < FUNCTION_CALL: (<NAMESPACE>)? <IDENTIFIER> <LPAREN> >
|       < FUNCTIONSUFFIX : (<IDENTIFIER>) >
|       < #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"
               ]
       >
|       < ILLEGAL_CHARACTER: (~[]) >
}


Lines 1-4 Link Here

(-)ELParserTreeConstants.java (-1 / +1 lines)
1	/* Generated By:JJTree: Do not edit this line. ./ELParserTreeConstants.java */	1	/* Generated By:JJTree: Do not edit this line. .\ELParserTreeConstants.java */
2		2
3	package org.apache.el.parser;	3	package org.apache.el.parser;
4		4

Return to bug 42565

Lines 3-133 Link Here

(-)ELParserConstants.java (-124 / +123 lines)
3		3
4	public interface ELParserConstants {	4	public interface ELParserConstants {
5		5
6	int EOF = 0;	6	int EOF = 0;
		7	int LITERAL_EXPRESSION = 1;
		8	int START_DYNAMIC_EXPRESSION = 2;
		9	int START_DEFERRED_EXPRESSION = 3;
		10	int INTEGER_LITERAL = 9;
		11	int FLOATING_POINT_LITERAL = 10;
		12	int EXPONENT = 11;
		13	int STRING_LITERAL = 12;
		14	int BADLY_ESCAPED_STRING_LITERAL = 13;
		15	int TRUE = 14;
		16	int FALSE = 15;
		17	int NULL = 16;
		18	int END_EXPRESSION = 17;
		19	int DOT = 18;
		20	int LPAREN = 19;
		21	int RPAREN = 20;
		22	int LBRACK = 21;
		23	int RBRACK = 22;
		24	int COLON = 23;
		25	int COMMA = 24;
		26	int GT0 = 25;
		27	int GT1 = 26;
		28	int LT0 = 27;
		29	int LT1 = 28;
		30	int GE0 = 29;
		31	int GE1 = 30;
		32	int LE0 = 31;
		33	int LE1 = 32;
		34	int EQ0 = 33;
		35	int EQ1 = 34;
		36	int NE0 = 35;
		37	int NE1 = 36;
		38	int NOT0 = 37;
		39	int NOT1 = 38;
		40	int AND0 = 39;
		41	int AND1 = 40;
		42	int OR0 = 41;
		43	int OR1 = 42;
		44	int EMPTY = 43;
		45	int INSTANCEOF = 44;
		46	int MULT = 45;
		47	int PLUS = 46;
		48	int MINUS = 47;
		49	int QUESTIONMARK = 48;
		50	int DIV0 = 49;
		51	int DIV1 = 50;
		52	int MOD0 = 51;
		53	int MOD1 = 52;
		54	int IDENTIFIER = 53;
		55	int NAMESPACE = 54;
		56	int NAMESPACE_NAME = 55;
		57	int FUNCTION_CALL = 56;
		58	int FUNCTIONSUFFIX = 57;
		59	int IMPL_OBJ_START = 58;
		60	int LETTER = 59;
		61	int DIGIT = 60;
		62	int ILLEGAL_CHARACTER = 61;
7		63
8	int LITERAL_EXPRESSION = 1;	64	int DEFAULT = 0;
		65	int IN_EXPRESSION = 1;
9		66
10	int START_DYNAMIC_EXPRESSION = 2;	67	String[] tokenImage = {
		68	"<EOF>",
		69	"<LITERAL_EXPRESSION>",
		70	"\"${\"",
		71	"\"#{\"",
		72	"\"\\\\\"",
		73	"\" \"",
		74	"\"\\t\"",
		75	"\"\\n\"",
		76	"\"\\r\"",
		77	"<INTEGER_LITERAL>",
		78	"<FLOATING_POINT_LITERAL>",
		79	"<EXPONENT>",
		80	"<STRING_LITERAL>",
		81	"<BADLY_ESCAPED_STRING_LITERAL>",
		82	"\"true\"",
		83	"\"false\"",
		84	"\"null\"",
		85	"\"}\"",
		86	"\".\"",
		87	"\"(\"",
		88	"\")\"",
		89	"\"[\"",
		90	"\"]\"",
		91	"\":\"",
		92	"\",\"",
		93	"\">\"",
		94	"\"gt\"",
		95	"\"<\"",
		96	"\"lt\"",
		97	"\">=\"",
		98	"\"ge\"",
		99	"\"<=\"",
		100	"\"le\"",
		101	"\"==\"",
		102	"\"eq\"",
		103	"\"!=\"",
		104	"\"ne\"",
		105	"\"!\"",
		106	"\"not\"",
		107	"\"&&\"",
		108	"\"and\"",
		109	"\"\|\|\"",
		110	"\"or\"",
		111	"\"empty\"",
		112	"\"instanceof\"",
		113	"\"*\"",
		114	"\"+\"",
		115	"\"-\"",
		116	"\"?\"",
		117	"\"/\"",
		118	"\"div\"",
		119	"\"%\"",
		120	"\"mod\"",
		121	"<IDENTIFIER>",
		122	"<NAMESPACE>",
		123	"<NAMESPACE_NAME>",
		124	"<FUNCTION_CALL>",
		125	"<FUNCTIONSUFFIX>",
		126	"\"#\"",
		127	"<LETTER>",
		128	"<DIGIT>",
		129	"<ILLEGAL_CHARACTER>",
		130	};
11		131
12	int START_DEFERRED_EXPRESSION = 3;
13
14	int INTEGER_LITERAL = 9;
15
16	int FLOATING_POINT_LITERAL = 10;
17
18	int EXPONENT = 11;
19
20	int STRING_LITERAL = 12;
21
22	int BADLY_ESCAPED_STRING_LITERAL = 13;
23
24	int TRUE = 14;
25
26	int FALSE = 15;
27
28	int NULL = 16;
29
30	int END_EXPRESSION = 17;
31
32	int DOT = 18;
33
34	int LPAREN = 19;
35
36	int RPAREN = 20;
37
38	int LBRACK = 21;
39
40	int RBRACK = 22;
41
42	int COLON = 23;
43
44	int COMMA = 24;
45
46	int GT0 = 25;
47
48	int GT1 = 26;
49
50	int LT0 = 27;
51
52	int LT1 = 28;
53
54	int GE0 = 29;
55
56	int GE1 = 30;
57
58	int LE0 = 31;
59
60	int LE1 = 32;
61
62	int EQ0 = 33;
63
64	int EQ1 = 34;
65
66	int NE0 = 35;
67
68	int NE1 = 36;
69
70	int NOT0 = 37;
71
72	int NOT1 = 38;
73
74	int AND0 = 39;
75
76	int AND1 = 40;
77
78	int OR0 = 41;
79
80	int OR1 = 42;
81
82	int EMPTY = 43;
83
84	int INSTANCEOF = 44;
85
86	int MULT = 45;
87
88	int PLUS = 46;
89
90	int MINUS = 47;
91
92	int QUESTIONMARK = 48;
93
94	int DIV0 = 49;
95
96	int DIV1 = 50;
97
98	int MOD0 = 51;
99
100	int MOD1 = 52;
101
102	int IDENTIFIER = 53;
103
104	int NAMESPACE = 54;
105
106	int FUNCTIONSUFFIX = 55;
107
108	int IMPL_OBJ_START = 56;
109
110	int LETTER = 57;
111
112	int DIGIT = 58;
113
114	int ILLEGAL_CHARACTER = 59;
115
116	int DEFAULT = 0;
117
118	int IN_EXPRESSION = 1;
119
120	String[] tokenImage = { "<EOF>", "<LITERAL_EXPRESSION>", "\"${\"",
121	"\"#{\"", "\"\\\\\"", "\" \"", "\"\\t\"", "\"\\n\"", "\"\\r\"",
122	"<INTEGER_LITERAL>", "<FLOATING_POINT_LITERAL>", "<EXPONENT>",
123	"<STRING_LITERAL>", "<BADLY_ESCAPED_STRING_LITERAL>", "\"true\"",
124	"\"false\"", "\"null\"", "\"}\"", "\".\"", "\"(\"", "\")\"",
125	"\"[\"", "\"]\"", "\":\"", "\",\"", "\">\"", "\"gt\"", "\"<\"",
126	"\"lt\"", "\">=\"", "\"ge\"", "\"<=\"", "\"le\"", "\"==\"",
127	"\"eq\"", "\"!=\"", "\"ne\"", "\"!\"", "\"not\"", "\"&&\"",
128	"\"and\"", "\"\|\|\"", "\"or\"", "\"empty\"", "\"instanceof\"",
129	"\"*\"", "\"+\"", "\"-\"", "\"?\"", "\"/\"", "\"div\"", "\"%\"",
130	"\"mod\"", "<IDENTIFIER>", "<NAMESPACE>", "<FUNCTIONSUFFIX>",
131	"\"#\"", "<LETTER>", "<DIGIT>", "<ILLEGAL_CHARACTER>", };
132
133	}	132	}

Lines 5-13 Link Here

(-)ELParser.jjt (-204 / +205 lines)
5	* The ASF licenses this file to You under the Apache License, Version 2.0	5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with	6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at	7	* the License. You may obtain a copy of the License at
8	*	8	*
9	* http://www.apache.org/licenses/LICENSE-2.0	9	* http://www.apache.org/licenses/LICENSE-2.0
10	*	10	*
11	* Unless required by applicable law or agreed to in writing, software	11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,	12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Lines 16-37 Link Here
16	*/	16	*/
17		17
18	/*	18	/*
19	Author: Jacob Hookom	19	Author: Jacob Hookom
20	Email: jacob at hookom.net	20	Email: jacob at hookom.net
21	*/	21	*/
22		22
23	/* == Option Declaration == */	23	/* == Option Declaration == */
24	options	24	options
25	{	25	{
26	STATIC=false;	26	STATIC=false;
27	NODE_PREFIX="Ast";	27	NODE_PREFIX="Ast";
28	VISITOR_EXCEPTION="javax.el.ELException";	28	VISITOR_EXCEPTION="javax.el.ELException";
29	VISITOR=false;	29	VISITOR=false;
30	MULTI=true;	30	MULTI=true;
31	NODE_DEFAULT_VOID=true;	31	NODE_DEFAULT_VOID=true;
32	JAVA_UNICODE_ESCAPE=false;	32	JAVA_UNICODE_ESCAPE=false;
33	UNICODE_INPUT=true;	33	UNICODE_INPUT=true;
34	BUILD_NODE_FILES=true;	34	BUILD_NODE_FILES=false;
35	}	35	}
36		36
37	/* == Parser Declaration == */	37	/* == Parser Declaration == */
Lines 41-54 Link Here
41	import javax.el.ELException;	41	import javax.el.ELException;
42	public class ELParser	42	public class ELParser
43	{	43	{
44	public static Node parse(String ref) throws ELException	44	public static Node parse(String ref) throws ELException
45	{	45	{
46	try {	46	try {
47	return (new ELParser(new StringReader(ref))).CompositeExpression();	47	return (new ELParser(new StringReader(ref))).CompositeExpression();
48	} catch (ParseException pe) {	48	} catch (ParseException pe) {
49	throw new ELException(pe.getMessage());	49	throw new ELException(pe.getMessage());
50	}	50	}
51	}	51	}
52	}	52	}
53	PARSER_END( ELParser )	53	PARSER_END( ELParser )
54		54
Lines 59-65 Link Here
59	*/	59	*/
60	AstCompositeExpression CompositeExpression() #CompositeExpression : {}	60	AstCompositeExpression CompositeExpression() #CompositeExpression : {}
61	{	61	{
62	(DeferredExpression() \| DynamicExpression() \| LiteralExpression())* <EOF> { return jjtThis; }	62	(DeferredExpression() \| DynamicExpression() \| LiteralExpression())* <EOF> { return jjtThis; }
63	}	63	}
64		64
65	/*	65	/*
Lines 68-74 Link Here
68	*/	68	*/
69	void LiteralExpression() #LiteralExpression : { Token t = null; }	69	void LiteralExpression() #LiteralExpression : { Token t = null; }
70	{	70	{
71	t=<LITERAL_EXPRESSION> { jjtThis.setImage(t.image); }	71	t=<LITERAL_EXPRESSION> { jjtThis.setImage(t.image); }
72	}	72	}
73		73
74	/*	74	/*
Lines 77-83 Link Here
77	*/	77	*/
78	void DeferredExpression() #DeferredExpression : {}	78	void DeferredExpression() #DeferredExpression : {}
79	{	79	{
80	<START_DEFERRED_EXPRESSION> Expression() <END_EXPRESSION>	80	<START_DEFERRED_EXPRESSION> Expression() <END_EXPRESSION>
81	}	81	}
82		82
83	/*	83	/*
Lines 86-92 Link Here
86	*/	86	*/
87	void DynamicExpression() #DynamicExpression : {}	87	void DynamicExpression() #DynamicExpression : {}
88	{	88	{
89	<START_DYNAMIC_EXPRESSION> Expression() <END_EXPRESSION>	89	<START_DYNAMIC_EXPRESSION> Expression() <END_EXPRESSION>
90	}	90	}
91		91
92	/*	92	/*
Lines 95-101 Link Here
95	*/	95	*/
96	void Expression() : {}	96	void Expression() : {}
97	{	97	{
98	Choice()	98	Choice()
99	}	99	}
100		100
101	/*	101	/*
Lines 104-110 Link Here
104	*/	104	*/
105	void Choice() : {}	105	void Choice() : {}
106	{	106	{
107	Or() (<QUESTIONMARK> Or() <COLON> Choice() #Choice(3))*	107	Or() (<QUESTIONMARK> Or() <COLON> Choice() #Choice(3))*
108	}	108	}
109		109
110	/*	110	/*
Lines 113-119 Link Here
113	*/	113	*/
114	void Or() : {}	114	void Or() : {}
115	{	115	{
116	And() ((<OR0>\|<OR1>) And() #Or(2))*	116	And() ((<OR0>\|<OR1>) And() #Or(2))*
117	}	117	}
118		118
119	/*	119	/*
Lines 122-128 Link Here
122	*/	122	*/
123	void And() : {}	123	void And() : {}
124	{	124	{
125	Equality() ((<AND0>\|<AND1>) Equality() #And(2))*	125	Equality() ((<AND0>\|<AND1>) Equality() #And(2))*
126	}	126	}
127		127
128	/*	128	/*
Lines 131-142 Link Here
131	*/	131	*/
132	void Equality() : {}	132	void Equality() : {}
133	{	133	{
134	Compare()	134	Compare()
135	(	135	(
136	((<EQ0>\|<EQ1>) Compare() #Equal(2))	136	((<EQ0>\|<EQ1>) Compare() #Equal(2))
137	\|	137	\|
138	((<NE0>\|<NE1>) Compare() #NotEqual(2))	138	((<NE0>\|<NE1>) Compare() #NotEqual(2))
139	)*	139	)*
140	}	140	}
141		141
142	/*	142	/*
Lines 145-160 Link Here
145	*/	145	*/
146	void Compare() : {}	146	void Compare() : {}
147	{	147	{
148	Math()	148	Math()
149	(	149	(
150	((<LT0>\|<LT1>) Math() #LessThan(2))	150	((<LT0>\|<LT1>) Math() #LessThan(2))
151	\|	151	\|
152	((<GT0>\|<GT1>) Math() #GreaterThan(2))	152	((<GT0>\|<GT1>) Math() #GreaterThan(2))
153	\|	153	\|
154	((<LE0>\|<LE1>) Math() #LessThanEqual(2))	154	((<LE0>\|<LE1>) Math() #LessThanEqual(2))
155	\|	155	\|
156	((<GE0>\|<GE1>) Math() #GreaterThanEqual(2))	156	((<GE0>\|<GE1>) Math() #GreaterThanEqual(2))
157	)*	157	)*
158	}	158	}
159		159
160	/*	160	/*
Lines 163-174 Link Here
163	*/	163	*/
164	void Math() : {}	164	void Math() : {}
165	{	165	{
166	Multiplication()	166	Multiplication()
167	(	167	(
168	(<PLUS> Multiplication() #Plus(2))	168	(<PLUS> Multiplication() #Plus(2))
169	\|	169	\|
170	(<MINUS> Multiplication() #Minus(2))	170	(<MINUS> Multiplication() #Minus(2))
171	)*	171	)*
172	}	172	}
173		173
174	/*	174	/*
Lines 177-190 Link Here
177	*/	177	*/
178	void Multiplication() : {}	178	void Multiplication() : {}
179	{	179	{
180	Unary()	180	Unary()
181	(	181	(
182	(<MULT> Unary() #Mult(2))	182	(<MULT> Unary() #Mult(2))
183	\|	183	\|
184	((<DIV0>\|<DIV1>) Unary() #Div(2))	184	((<DIV0>\|<DIV1>) Unary() #Div(2))
185	\|	185	\|
186	((<MOD0>\|<MOD1>) Unary() #Mod(2))	186	((<MOD0>\|<MOD1>) Unary() #Mod(2))
187	)*	187	)*
188	}	188	}
189		189
190	/*	190	/*
Lines 193-205 Link Here
193	*/	193	*/
194	void Unary() : {}	194	void Unary() : {}
195	{	195	{
196	<MINUS> Unary() #Negative	196	<MINUS> Unary() #Negative
197	\|	197	\|
198	(<NOT0>\|<NOT1>) Unary() #Not	198	(<NOT0>\|<NOT1>) Unary() #Not
199	\|	199	\|
200	<EMPTY> Unary() #Empty	200	<EMPTY> Unary() #Empty
201	\|	201	\|
202	Value()	202	Value()
203	}	203	}
204		204
205	/*	205	/*
Lines 208-214 Link Here
208	*/	208	*/
209	void Value() : {}	209	void Value() : {}
210	{	210	{
211	(ValuePrefix() (ValueSuffix())*) #Value(>1)	211	(ValuePrefix() (ValueSuffix())*) #Value(>1)
212	}	212	}
213		213
214	/*	214	/*
Lines 217-224 Link Here
217	*/	217	*/
218	void ValuePrefix() : {}	218	void ValuePrefix() : {}
219	{	219	{
220	Literal()	220	Literal()
221	\| NonLiteral()	221	\| NonLiteral()
222	}	222	}
223		223
224	/*	224	/*
Lines 227-233 Link Here
227	*/	227	*/
228	void ValueSuffix() : {}	228	void ValueSuffix() : {}
229	{	229	{
230	DotSuffix() \| BracketSuffix()	230	DotSuffix() \| BracketSuffix()
231	}	231	}
232		232
233	/*	233	/*
Lines 236-242 Link Here
236	*/	236	*/
237	void DotSuffix() #DotSuffix : { Token t = null; }	237	void DotSuffix() #DotSuffix : { Token t = null; }
238	{	238	{
239	<DOT> t=<IDENTIFIER> { jjtThis.setImage(t.image); }	239	<DOT> t=<IDENTIFIER> { jjtThis.setImage(t.image); }
240	}	240	}
241		241
242	/*	242	/*
Lines 245-251 Link Here
245	*/	245	*/
246	void BracketSuffix() #BracketSuffix : {}	246	void BracketSuffix() #BracketSuffix : {}
247	{	247	{
248	<LBRACK> Expression() <RBRACK>	248	<LBRACK> Expression() <RBRACK>
249	}	249	}
250		250
251	/*	251	/*
Lines 254-262 Link Here
254	*/	254	*/
255	void NonLiteral() : {}	255	void NonLiteral() : {}
256	{	256	{
257	<LPAREN> Expression() <RPAREN>	257	<LPAREN> Expression() <RPAREN>
258	\| LOOKAHEAD(3) Function()	258	\| LOOKAHEAD(3) Function()
259	\| Identifier()	259	\| Identifier()
260	}	260	}
261		261
262	/*	262	/*
Lines 265-271 Link Here
265	*/	265	*/
266	void Identifier() #Identifier : { Token t = null; }	266	void Identifier() #Identifier : { Token t = null; }
267	{	267	{
268	t=<IDENTIFIER> { jjtThis.setImage(t.image); }	268	t=<IDENTIFIER> { jjtThis.setImage(t.image); }
269	}	269	}
270		270
271	/*	271	/*
Lines 274-293 Link Here
274	*/	274	*/
275	void Function() #Function :	275	void Function() #Function :
276	{	276	{
277	Token t0 = null;	277	Token tx = null;
278	Token t1 = null;
279	}	278	}
280	{	279	{
281	(t0=<NAMESPACE>)? t1=<IDENTIFIER>	280	(tx=<FUNCTION_CALL> ) (Expression() (<COMMA> Expression())*)? <RPAREN>
282	{	281	{
283	if (t0 != null) {	282	if (tx.image.indexOf(":")!=-1) {
284	jjtThis.setPrefix(t0.image.substring(0, t0.image.length() - 1));	283	jjtThis.setPrefix(tx.image.substring(0, tx.image.indexOf(":")));
285	jjtThis.setLocalName(t1.image);	284	jjtThis.setLocalName(tx.image.substring(tx.image.indexOf(":") + 1, tx.image.length() - 1));
286	} else {	285	} else {
287	jjtThis.setLocalName(t1.image);	286	jjtThis.setLocalName(tx.image.substring(0, tx.image.length() - 1));
288	}	287	}
289	}	288	}
290	<LPAREN> (Expression() (<COMMA> Expression())*)? <RPAREN>
291	}	289	}
292		290
293	/*	291	/*
Lines 296-306 Link Here
296	*/	294	*/
297	void Literal() : {}	295	void Literal() : {}
298	{	296	{
299	Boolean()	297	Boolean()
300	\| FloatingPoint()	298	\| FloatingPoint()
301	\| Integer()	299	\| Integer()
302	\| String()	300	\| String()
303	\| Null()	301	\| Null()
304	}	302	}
305		303
306	/*	304	/*
Lines 309-316 Link Here
309	*/	307	*/
310	void Boolean() : {}	308	void Boolean() : {}
311	{	309	{
312	<TRUE> #True	310	<TRUE> #True
313	\| <FALSE> #False	311	\| <FALSE> #False
314	}	312	}
315		313
316	/*	314	/*
Lines 319-325 Link Here
319	*/	317	*/
320	void FloatingPoint() #FloatingPoint : { Token t = null; }	318	void FloatingPoint() #FloatingPoint : { Token t = null; }
321	{	319	{
322	t=<FLOATING_POINT_LITERAL> { jjtThis.setImage(t.image); }	320	t=<FLOATING_POINT_LITERAL> { jjtThis.setImage(t.image); }
323	}	321	}
324		322
325	/*	323	/*
Lines 328-334 Link Here
328	*/	326	*/
329	void Integer() #Integer : { Token t = null; }	327	void Integer() #Integer : { Token t = null; }
330	{	328	{
331	t=<INTEGER_LITERAL> { jjtThis.setImage(t.image); }	329	t=<INTEGER_LITERAL> { jjtThis.setImage(t.image); }
332	}	330	}
333		331
334	/*	332	/*
Lines 337-343 Link Here
337	*/	335	*/
338	void String() #String : { Token t = null; }	336	void String() #String : { Token t = null; }
339	{	337	{
340	t=<STRING_LITERAL> { jjtThis.setImage(t.image); }	338	t=<STRING_LITERAL> { jjtThis.setImage(t.image); }
341	}	339	}
342		340
343	/*	341	/*
Lines 346-371 Link Here
346	*/	344	*/
347	void Null() #Null : {}	345	void Null() #Null : {}
348	{	346	{
349	<NULL>	347	<NULL>
350	}	348	}
351		349
352		350
353	/* ==================================================================================== */	351	/* ==================================================================================== */
354	<DEFAULT> TOKEN :	352	<DEFAULT> TOKEN :
355	{	353	{
356	< LITERAL_EXPRESSION:	354	< LITERAL_EXPRESSION:
357	((~["\\", "$", "#"])	355	((~["\\", "$", "#"])
358	\| ("\\" ("\\" \| "$" \| "#"))	356	\| ("\\" ("\\" \| "$" \| "#"))
359	\| ("$" ~["{", "$"])	357	\| ("$" ~["{", "$"])
360	\| ("#" ~["{", "#"])	358	\| ("#" ~["{", "#"])
361	)+	359	)+
362	\| "$"	360	\| "$"
363	\| "#"	361	\| "#"
364	>	362	>
365	\|	363	\|
366	< START_DYNAMIC_EXPRESSION: "${" > : IN_EXPRESSION	364	< START_DYNAMIC_EXPRESSION: "${" > : IN_EXPRESSION
367	\|	365	\|
368	< START_DEFERRED_EXPRESSION: "#{" > : IN_EXPRESSION	366	< START_DEFERRED_EXPRESSION: "#{" > : IN_EXPRESSION
369	}	367	}
370		368
371	<DEFAULT> SKIP : { "\\" }	369	<DEFAULT> SKIP : { "\\" }
Lines 374-471 Link Here
374		372
375	<IN_EXPRESSION> TOKEN :	373	<IN_EXPRESSION> TOKEN :
376	{	374	{
377	< INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >	375	< INTEGER_LITERAL: ["0"-"9"] (["0"-"9"])* >
378	\| < FLOATING_POINT_LITERAL: (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?	376	\| < FLOATING_POINT_LITERAL: (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
379	\| "." (["0"-"9"])+ (<EXPONENT>)?	377	\| "." (["0"-"9"])+ (<EXPONENT>)?
380	\| (["0"-"9"])+ <EXPONENT>	378	\| (["0"-"9"])+ <EXPONENT>
381	>	379	>
382	\| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >	380	\| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
383	\| < STRING_LITERAL: ("\"" ((~["\"","\\"])	381	\| < STRING_LITERAL: ("\"" ((~["\"","\\"])
384	\| ("\\" ( ["\\","\""] )))* "\"")	382	\| ("\\" ( ["\\","\""] )))* "\"")
385	\| ("\'" ((~["\'","\\"])	383	\| ("\'" ((~["\'","\\"])
386	\| ("\\" ( ["\\","\'"] )))* "\'")	384	\| ("\\" ( ["\\","\'"] )))* "\'")
387	>	385	>
388	\| < BADLY_ESCAPED_STRING_LITERAL: ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] )))	386	\| < BADLY_ESCAPED_STRING_LITERAL: ("\"" (~["\"","\\"])* ("\\" ( ~["\\","\""] )))
389	\| ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))	387	\| ("\'" (~["\'","\\"])* ("\\" ( ~["\\","\'"] )))
390	>	388	>
391	\| < TRUE : "true" >	389	\| < TRUE : "true" >
392	\| < FALSE : "false" >	390	\| < FALSE : "false" >
393	\| < NULL : "null" >	391	\| < NULL : "null" >
394	\| < END_EXPRESSION : "}" > : DEFAULT	392	\| < END_EXPRESSION : "}" > : DEFAULT
395	\| < DOT : "." >	393	\| < DOT : "." >
396	\| < LPAREN : "(" >	394	\| < LPAREN : "(" >
397	\| < RPAREN : ")" >	395	\| < RPAREN : ")" >
398	\| < LBRACK : "[" >	396	\| < LBRACK : "[" >
399	\| < RBRACK : "]" >	397	\| < RBRACK : "]" >
400	\| < COLON : ":" >	398	\| < COLON : ":" >
401	\| < COMMA : "," >	399	\| < COMMA : "," >
402	\| < GT0 : ">" >	400	\| < GT0 : ">" >
403	\| < GT1 : "gt" >	401	\| < GT1 : "gt" >
404	\| < LT0 : "<" >	402	\| < LT0 : "<" >
405	\| < LT1 : "lt" >	403	\| < LT1 : "lt" >
406	\| < GE0 : ">=" >	404	\| < GE0 : ">=" >
407	\| < GE1 : "ge" >	405	\| < GE1 : "ge" >
408	\| < LE0 : "<=" >	406	\| < LE0 : "<=" >
409	\| < LE1 : "le" >	407	\| < LE1 : "le" >
410	\| < EQ0 : "==" >	408	\| < EQ0 : "==" >
411	\| < EQ1 : "eq" >	409	\| < EQ1 : "eq" >
412	\| < NE0 : "!=" >	410	\| < NE0 : "!=" >
413	\| < NE1 : "ne" >	411	\| < NE1 : "ne" >
414	\| < NOT0 : "!" >	412	\| < NOT0 : "!" >
415	\| < NOT1 : "not" >	413	\| < NOT1 : "not" >
416	\| < AND0 : "&&" >	414	\| < AND0 : "&&" >
417	\| < AND1 : "and" >	415	\| < AND1 : "and" >
418	\| < OR0 : "\|\|" >	416	\| < OR0 : "\|\|" >
419	\| < OR1 : "or" >	417	\| < OR1 : "or" >
420	\| < EMPTY : "empty" >	418	\| < EMPTY : "empty" >
421	\| < INSTANCEOF : "instanceof" >	419	\| < INSTANCEOF : "instanceof" >
422	\| < MULT : "*" >	420	\| < MULT : "*" >
423	\| < PLUS : "+" >	421	\| < PLUS : "+" >
424	\| < MINUS : "-" >	422	\| < MINUS : "-" >
425	\| < QUESTIONMARK : "?" >	423	\| < QUESTIONMARK : "?" >
426	\| < DIV0 : "/" >	424	\| < DIV0 : "/" >
427	\| < DIV1 : "div" >	425	\| < DIV1 : "div" >
428	\| < MOD0 : "%" >	426	\| < MOD0 : "%" >
429	\| < MOD1 : "mod" >	427	\| < MOD1 : "mod" >
430	\| < IDENTIFIER : (<LETTER>\|<IMPL_OBJ_START>) (<LETTER>\|<DIGIT>)* >	428	\| < IDENTIFIER : (<LETTER>\|<IMPL_OBJ_START>) (<LETTER>\|<DIGIT>)* >
431	\| < NAMESPACE : (<IDENTIFIER> (<IDENTIFIER>\|<MINUS>\|<DOT>)* <COLON>) >	429	\| < #NAMESPACE : ( <NAMESPACE_NAME> <COLON>) >
432	\| < FUNCTIONSUFFIX : (<IDENTIFIER>) >	430	\| < #NAMESPACE_NAME: (<IDENTIFIER> (<LETTER>\|<DIGIT>\|<MINUS>\|<DOT>)*) >
433	\| < #IMPL_OBJ_START: "#" >	431	\| < FUNCTION_CALL: (<NAMESPACE>)? <IDENTIFIER> <LPAREN> >
434	\| < #LETTER:	432	\| < FUNCTIONSUFFIX : (<IDENTIFIER>) >
435	[	433	\| < #IMPL_OBJ_START: "#" >
436	"\u0024",	434	\| < #LETTER:
437	"\u0041"-"\u005a",	435	[
438	"\u005f",	436	"\u0024",
439	"\u0061"-"\u007a",	437	"\u0041"-"\u005a",
440	"\u00c0"-"\u00d6",	438	"\u005f",
441	"\u00d8"-"\u00f6",	439	"\u0061"-"\u007a",
442	"\u00f8"-"\u00ff",	440	"\u00c0"-"\u00d6",
443	"\u0100"-"\u1fff",	441	"\u00d8"-"\u00f6",
444	"\u3040"-"\u318f",	442	"\u00f8"-"\u00ff",
445	"\u3300"-"\u337f",	443	"\u0100"-"\u1fff",
446	"\u3400"-"\u3d2d",	444	"\u3040"-"\u318f",
447	"\u4e00"-"\u9fff",	445	"\u3300"-"\u337f",
448	"\uf900"-"\ufaff"	446	"\u3400"-"\u3d2d",
449	]	447	"\u4e00"-"\u9fff",
450	>	448	"\uf900"-"\ufaff"
451	\| < #DIGIT:	449	]
452	[	450	>
453	"\u0030"-"\u0039",	451	\| < #DIGIT:
454	"\u0660"-"\u0669",	452	[
455	"\u06f0"-"\u06f9",	453	"\u0030"-"\u0039",
456	"\u0966"-"\u096f",	454	"\u0660"-"\u0669",
457	"\u09e6"-"\u09ef",	455	"\u06f0"-"\u06f9",
458	"\u0a66"-"\u0a6f",	456	"\u0966"-"\u096f",
459	"\u0ae6"-"\u0aef",	457	"\u09e6"-"\u09ef",
460	"\u0b66"-"\u0b6f",	458	"\u0a66"-"\u0a6f",
461	"\u0be7"-"\u0bef",	459	"\u0ae6"-"\u0aef",
462	"\u0c66"-"\u0c6f",	460	"\u0b66"-"\u0b6f",
463	"\u0ce6"-"\u0cef",	461	"\u0be7"-"\u0bef",
464	"\u0d66"-"\u0d6f",	462	"\u0c66"-"\u0c6f",
465	"\u0e50"-"\u0e59",	463	"\u0ce6"-"\u0cef",
466	"\u0ed0"-"\u0ed9",	464	"\u0d66"-"\u0d6f",
467	"\u1040"-"\u1049"	465	"\u0e50"-"\u0e59",
468	]	466	"\u0ed0"-"\u0ed9",
469	>	467	"\u1040"-"\u1049"
470	\| < ILLEGAL_CHARACTER: (~[]) >	468	]
		469	>
		470	\| < ILLEGAL_CHARACTER: (~[]) >
471	}	471	}
		472