Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
   package org.apache.el.parser;

Token Manager.
   
   @SuppressWarnings("all"// Ignore warnings in generated code
   public class ELParserTokenManager implements ELParserConstants
   {

  
Debug output.
   
    public  java.io.PrintStream debugStream = .;
  
Set debug output.
  
    public  void setDebugStream(java.io.PrintStream ds) {  = ds; }
  private final int jjStopStringLiteralDfa_0(int poslong active0)
  {
     switch (pos)
     {
        case 0:
           if ((active0 & 0xcL) != 0L)
           {
               = 1;
              return 5;
           }
           return -1;
        default :
           return -1;
     }
  }
  private final int jjStartNfa_0(int poslong active0)
  {
     return jjMoveNfa_0(jjStopStringLiteralDfa_0(posactive0), pos + 1);
  }
  private int jjStopAtPos(int posint kind)
  {
      = kind;
      = pos;
     return pos + 1;
  }
  private int jjMoveStringLiteralDfa0_0()
  {
     switch()
     {
        case 35:
           return jjMoveStringLiteralDfa1_0(0x8L);
        case 36:
           return jjMoveStringLiteralDfa1_0(0x4L);
        default :
           return jjMoveNfa_0(7, 0);
     }
  }
  private int jjMoveStringLiteralDfa1_0(long active0)
  {
     try {  = .readChar(); }
     catch(java.io.IOException e) {
        jjStopStringLiteralDfa_0(0, active0);
        return 1;
     }
     switch()
     {
        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);
  }
  static final long[] jjbitVec0 = {
     0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  };
  static final long[] jjbitVec2 = {
     0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  };
  private int jjMoveNfa_0(int startStateint curPos)
  {
     int startsAt = 0;
      = 8;
     int i = 1;
     [0] = startState;
     int kind = 0x7fffffff;
     for (;;)
     {
        if (++ == 0x7fffffff)
           ReInitRounds();
        if ( < 64)
        {
           long l = 1L << ;
           do
           {
              switch([--i])
              {
                 case 7:
                    if ((0xffffffe7ffffffffL & l) != 0L)
                    {
                       if (kind > 1)
                          kind = 1;
                       jjCheckNAddStates(0, 4);
                   }
                   else if ((0x1800000000L & l) != 0L)
                   {
                      if (kind > 1)
                         kind = 1;
                      jjCheckNAdd(5);
                   }
                   if ((0xffffffe7ffffffffL & l) != 0L)
                      jjCheckNAddTwoStates(0, 1);
                   break;
                case 0:
                   if ((0xffffffe7ffffffffL & l) != 0L)
                      jjCheckNAddTwoStates(0, 1);
                   break;
                case 2:
                   if ((0xffffffe7ffffffffL & l) == 0L)
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(0, 4);
                   break;
                case 3:
                   if ((0xffffffe7ffffffffL & l) != 0L)
                      jjCheckNAddTwoStates(3, 4);
                   break;
                case 4:
                   if ((0x1800000000L & l) != 0L)
                      jjCheckNAdd(5);
                   break;
                case 5:
                   if ((0xffffffe7ffffffffL & l) == 0L)
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(5, 8);
                   break;
                case 6:
                   if ((0x1800000000L & l) == 0L)
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(9, 13);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else if ( < 128)
       {
          long l = 1L << ( & 077);
          do
          {
             switch([--i])
             {
                case 7:
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(0, 4);
                   if ((0xffffffffefffffffL & l) != 0L)
                      jjCheckNAddTwoStates(0, 1);
                   else if ( == 92)
                   {
                      if (kind > 1)
                         kind = 1;
                      jjCheckNAddStates(14, 17);
                   }
                   break;
                case 0:
                   if ((0xffffffffefffffffL & l) != 0L)
                      jjCheckNAddTwoStates(0, 1);
                   break;
                case 1:
                   if ( != 92)
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(14, 17);
                   break;
                case 2:
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(0, 4);
                   break;
                case 3:
                   jjCheckNAddTwoStates(3, 4);
                   break;
                case 5:
                   if ((0xf7ffffffffffffffL & l) == 0L)
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(5, 8);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else
       {
          int hiByte = (int)( >> 8);
          int i1 = hiByte >> 6;
          long l1 = 1L << (hiByte & 077);
          int i2 = ( & 0xff) >> 6;
          long l2 = 1L << ( & 077);
          do
          {
             switch([--i])
             {
                case 7:
                   if (jjCanMove_0(hiBytei1i2l1l2))
                      jjCheckNAddTwoStates(0, 1);
                   if (jjCanMove_0(hiBytei1i2l1l2))
                   {
                      if (kind > 1)
                         kind = 1;
                      jjCheckNAddStates(0, 4);
                   }
                   break;
                case 0:
                   if (jjCanMove_0(hiBytei1i2l1l2))
                      jjCheckNAddTwoStates(0, 1);
                   break;
                case 2:
                   if (!jjCanMove_0(hiBytei1i2l1l2))
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(0, 4);
                   break;
                case 3:
                   if (jjCanMove_0(hiBytei1i2l1l2))
                      jjCheckNAddTwoStates(3, 4);
                   break;
                case 5:
                   if (!jjCanMove_0(hiBytei1i2l1l2))
                      break;
                   if (kind > 1)
                      kind = 1;
                   jjCheckNAddStates(5, 8);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       if (kind != 0x7fffffff)
       {
           = kind;
           = curPos;
          kind = 0x7fffffff;
       }
       ++curPos;
       if ((i = ) == (startsAt = 8 - ( = startsAt)))
          return curPos;
       try {  = .readChar(); }
       catch(java.io.IOException e) { return curPos; }
    }
 }
 private final int jjStopStringLiteralDfa_1(int poslong active0)
 {
    switch (pos)
    {
       case 0:
          if ((active0 & 0x10000L) != 0L)
             return 1;
          if ((active0 & 0x5075555007000L) != 0L)
          {
              = 51;
             return 30;
          }
          return -1;
       case 1:
          if ((active0 & 0x5065000007000L) != 0L)
          {
              = 51;
              = 1;
             return 30;
          }
          if ((active0 & 0x10555000000L) != 0L)
             return 30;
          return -1;
       case 2:
          if ((active0 & 0x5005000000000L) != 0L)
             return 30;
          if ((active0 & 0x60000007000L) != 0L)
          {
              = 51;
              = 2;
             return 30;
          }
          return -1;
       case 3:
          if ((active0 & 0x5000L) != 0L)
             return 30;
          if ((active0 & 0x60000002000L) != 0L)
          {
              = 51;
              = 3;
             return 30;
          }
          return -1;
       case 4:
          if ((active0 & 0x40000000000L) != 0L)
          {
              = 51;
              = 4;
             return 30;
          }
          if ((active0 & 0x20000002000L) != 0L)
             return 30;
          return -1;
       case 5:
          if ((active0 & 0x40000000000L) != 0L)
          {
              = 51;
              = 5;
             return 30;
          }
          return -1;
       case 6:
          if ((active0 & 0x40000000000L) != 0L)
          {
              = 51;
              = 6;
             return 30;
          }
          return -1;
       case 7:
          if ((active0 & 0x40000000000L) != 0L)
          {
              = 51;
              = 7;
             return 30;
          }
          return -1;
       case 8:
          if ((active0 & 0x40000000000L) != 0L)
          {
              = 51;
              = 8;
             return 30;
          }
          return -1;
       default :
          return -1;
    }
 }
 private final int jjStartNfa_1(int poslong active0)
 {
    return jjMoveNfa_1(jjStopStringLiteralDfa_1(posactive0), pos + 1);
 }
 {
    switch()
    {
       case 33:
           = 35;
          return jjMoveStringLiteralDfa1_1(0x200000000L);
       case 37:
          return jjStopAtPos(0, 49);
       case 38:
          return jjMoveStringLiteralDfa1_1(0x2000000000L);
       case 40:
          return jjStopAtPos(0, 17);
       case 41:
          return jjStopAtPos(0, 18);
       case 42:
          return jjStopAtPos(0, 43);
       case 43:
          return jjStopAtPos(0, 44);
       case 44:
          return jjStopAtPos(0, 22);
       case 45:
          return jjStopAtPos(0, 45);
       case 46:
          return jjStartNfaWithStates_1(0, 16, 1);
       case 47:
          return jjStopAtPos(0, 47);
       case 58:
          return jjStopAtPos(0, 21);
       case 60:
           = 25;
          return jjMoveStringLiteralDfa1_1(0x20000000L);
       case 61:
          return jjMoveStringLiteralDfa1_1(0x80000000L);
       case 62:
           = 23;
          return jjMoveStringLiteralDfa1_1(0x8000000L);
       case 63:
          return jjStopAtPos(0, 46);
       case 91:
          return jjStopAtPos(0, 19);
       case 93:
          return jjStopAtPos(0, 20);
       case 97:
          return jjMoveStringLiteralDfa1_1(0x4000000000L);
       case 100:
          return jjMoveStringLiteralDfa1_1(0x1000000000000L);
       case 101:
          return jjMoveStringLiteralDfa1_1(0x20100000000L);
       case 102:
          return jjMoveStringLiteralDfa1_1(0x2000L);
       case 103:
          return jjMoveStringLiteralDfa1_1(0x11000000L);
       case 105:
          return jjMoveStringLiteralDfa1_1(0x40000000000L);
       case 108:
          return jjMoveStringLiteralDfa1_1(0x44000000L);
       case 109:
          return jjMoveStringLiteralDfa1_1(0x4000000000000L);
       case 110:
          return jjMoveStringLiteralDfa1_1(0x1400004000L);
       case 111:
          return jjMoveStringLiteralDfa1_1(0x10000000000L);
       case 116:
          return jjMoveStringLiteralDfa1_1(0x1000L);
       case 124:
          return jjMoveStringLiteralDfa1_1(0x8000000000L);
       case 125:
          return jjStopAtPos(0, 15);
       default :
          return jjMoveNfa_1(0, 0);
    }
 }
 private int jjMoveStringLiteralDfa1_1(long active0)
 {
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(0, active0);
       return 1;
    }
    switch()
    {
       case 38:
          if ((active0 & 0x2000000000L) != 0L)
             return jjStopAtPos(1, 37);
          break;
       case 61:
          if ((active0 & 0x8000000L) != 0L)
             return jjStopAtPos(1, 27);
          else 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);
          break;
       case 97:
          return jjMoveStringLiteralDfa2_1(active0, 0x2000L);
       case 101:
          if ((active0 & 0x10000000L) != 0L)
             return jjStartNfaWithStates_1(1, 28, 30);
          else if ((active0 & 0x40000000L) != 0L)
             return jjStartNfaWithStates_1(1, 30, 30);
          else if ((active0 & 0x400000000L) != 0L)
             return jjStartNfaWithStates_1(1, 34, 30);
          break;
       case 105:
          return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000L);
       case 109:
          return jjMoveStringLiteralDfa2_1(active0, 0x20000000000L);
       case 110:
          return jjMoveStringLiteralDfa2_1(active0, 0x44000000000L);
       case 111:
          return jjMoveStringLiteralDfa2_1(active0, 0x4001000000000L);
       case 113:
          if ((active0 & 0x100000000L) != 0L)
             return jjStartNfaWithStates_1(1, 32, 30);
          break;
       case 114:
          if ((active0 & 0x10000000000L) != 0L)
             return jjStartNfaWithStates_1(1, 40, 30);
          return jjMoveStringLiteralDfa2_1(active0, 0x1000L);
       case 116:
          if ((active0 & 0x1000000L) != 0L)
             return jjStartNfaWithStates_1(1, 24, 30);
          else if ((active0 & 0x4000000L) != 0L)
             return jjStartNfaWithStates_1(1, 26, 30);
          break;
       case 117:
          return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
       case 124:
          if ((active0 & 0x8000000000L) != 0L)
             return jjStopAtPos(1, 39);
          break;
       default :
          break;
    }
    return jjStartNfa_1(0, active0);
 }
 private int jjMoveStringLiteralDfa2_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(0, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(1, active0);
       return 2;
    }
    switch()
    {
       case 100:
          if ((active0 & 0x4000000000L) != 0L)
             return jjStartNfaWithStates_1(2, 38, 30);
          else if ((active0 & 0x4000000000000L) != 0L)
             return jjStartNfaWithStates_1(2, 50, 30);
          break;
       case 108:
          return jjMoveStringLiteralDfa3_1(active0, 0x6000L);
       case 112:
          return jjMoveStringLiteralDfa3_1(active0, 0x20000000000L);
       case 115:
          return jjMoveStringLiteralDfa3_1(active0, 0x40000000000L);
       case 116:
          if ((active0 & 0x1000000000L) != 0L)
             return jjStartNfaWithStates_1(2, 36, 30);
          break;
       case 117:
          return jjMoveStringLiteralDfa3_1(active0, 0x1000L);
       case 118:
          if ((active0 & 0x1000000000000L) != 0L)
             return jjStartNfaWithStates_1(2, 48, 30);
          break;
       default :
          break;
    }
    return jjStartNfa_1(1, active0);
 }
 private int jjMoveStringLiteralDfa3_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(1, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(2, active0);
       return 3;
    }
    switch()
    {
       case 101:
          if ((active0 & 0x1000L) != 0L)
             return jjStartNfaWithStates_1(3, 12, 30);
          break;
       case 108:
          if ((active0 & 0x4000L) != 0L)
             return jjStartNfaWithStates_1(3, 14, 30);
          break;
       case 115:
          return jjMoveStringLiteralDfa4_1(active0, 0x2000L);
       case 116:
          return jjMoveStringLiteralDfa4_1(active0, 0x60000000000L);
       default :
          break;
    }
    return jjStartNfa_1(2, active0);
 }
 private int jjMoveStringLiteralDfa4_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(2, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(3, active0);
       return 4;
    }
    switch()
    {
       case 97:
          return jjMoveStringLiteralDfa5_1(active0, 0x40000000000L);
       case 101:
          if ((active0 & 0x2000L) != 0L)
             return jjStartNfaWithStates_1(4, 13, 30);
          break;
       case 121:
          if ((active0 & 0x20000000000L) != 0L)
             return jjStartNfaWithStates_1(4, 41, 30);
          break;
       default :
          break;
    }
    return jjStartNfa_1(3, active0);
 }
 private int jjMoveStringLiteralDfa5_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(3, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(4, active0);
       return 5;
    }
    switch()
    {
       case 110:
          return jjMoveStringLiteralDfa6_1(active0, 0x40000000000L);
       default :
          break;
    }
    return jjStartNfa_1(4, active0);
 }
 private int jjMoveStringLiteralDfa6_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(4, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(5, active0);
       return 6;
    }
    switch()
    {
       case 99:
          return jjMoveStringLiteralDfa7_1(active0, 0x40000000000L);
       default :
          break;
    }
    return jjStartNfa_1(5, active0);
 }
 private int jjMoveStringLiteralDfa7_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(5, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(6, active0);
       return 7;
    }
    switch()
    {
       case 101:
          return jjMoveStringLiteralDfa8_1(active0, 0x40000000000L);
       default :
          break;
    }
    return jjStartNfa_1(6, active0);
 }
 private int jjMoveStringLiteralDfa8_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(6, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(7, active0);
       return 8;
    }
    switch()
    {
       case 111:
          return jjMoveStringLiteralDfa9_1(active0, 0x40000000000L);
       default :
          break;
    }
    return jjStartNfa_1(7, active0);
 }
 private int jjMoveStringLiteralDfa9_1(long old0long active0)
 {
    if (((active0 &= old0)) == 0L)
       return jjStartNfa_1(7, old0);
    try {  = .readChar(); }
    catch(java.io.IOException e) {
       jjStopStringLiteralDfa_1(8, active0);
       return 9;
    }
    switch()
    {
       case 102:
          if ((active0 & 0x40000000000L) != 0L)
             return jjStartNfaWithStates_1(9, 42, 30);
          break;
       default :
          break;
    }
    return jjStartNfa_1(8, active0);
 }
 private int jjStartNfaWithStates_1(int posint kindint state)
 {
     = kind;
     = pos;
    try {  = .readChar(); }
    catch(java.io.IOException e) { return pos + 1; }
    return jjMoveNfa_1(statepos + 1);
 }
 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 int jjMoveNfa_1(int startStateint curPos)
 {
    int startsAt = 0;
     = 30;
    int i = 1;
    [0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
       if (++ == 0x7fffffff)
          ReInitRounds();
       if ( < 64)
       {
          long l = 1L << ;
          do
          {
             switch([--i])
             {
                case 0:
                   if ((0x3ff000000000000L & l) != 0L)
                   {
                      if (kind > 8)
                         kind = 8;
                      jjCheckNAddStates(18, 22);
                   }
                   else if ((0x1800000000L & l) != 0L)
                   {
                      if (kind > 51)
                         kind = 51;
                      jjCheckNAddTwoStates(28, 29);
                   }
                   else if ( == 39)
                      jjCheckNAddStates(23, 25);
                   else if ( == 34)
                      jjCheckNAddStates(26, 28);
                   else if ( == 46)
                      jjCheckNAdd(1);
                   break;
                case 30:
                   if ((0x3ff001000000000L & l) != 0L)
                   {
                      if (kind > 52)
                         kind = 52;
                      jjCheckNAdd(29);
                   }
                   if ((0x3ff001000000000L & l) != 0L)
                   {
                      if (kind > 51)
                         kind = 51;
                      jjCheckNAdd(28);
                   }
                   break;
                case 1:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAddTwoStates(1, 2);
                   break;
                case 3:
                   if ((0x280000000000L & l) != 0L)
                      jjCheckNAdd(4);
                   break;
                case 4:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAdd(4);
                   break;
                case 5:
                   if ( == 34)
                      jjCheckNAddStates(26, 28);
                   break;
                case 6:
                   if ((0xfffffffbffffffffL & l) != 0L)
                      jjCheckNAddStates(26, 28);
                   break;
                case 8:
                   if ((0x8400000000L & l) != 0L)
                      jjCheckNAddStates(26, 28);
                   break;
                case 9:
                   if ( == 34 && kind > 11)
                      kind = 11;
                   break;
                case 10:
                   if ( == 39)
                      jjCheckNAddStates(23, 25);
                   break;
                case 11:
                   if ((0xffffff7fffffffffL & l) != 0L)
                      jjCheckNAddStates(23, 25);
                   break;
                case 13:
                   if ((0x8400000000L & l) != 0L)
                      jjCheckNAddStates(23, 25);
                   break;
                case 14:
                   if ( == 39 && kind > 11)
                      kind = 11;
                   break;
                case 15:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 8)
                      kind = 8;
                   jjCheckNAddStates(18, 22);
                   break;
                case 16:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 8)
                      kind = 8;
                   jjCheckNAdd(16);
                   break;
                case 17:
                   if ((0x3ff000000000000L & l) != 0L)
                      jjCheckNAddTwoStates(17, 18);
                   break;
                case 18:
                   if ( != 46)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAddTwoStates(19, 20);
                   break;
                case 19:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAddTwoStates(19, 20);
                   break;
                case 21:
                   if ((0x280000000000L & l) != 0L)
                      jjCheckNAdd(22);
                   break;
                case 22:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAdd(22);
                   break;
                case 23:
                   if ((0x3ff000000000000L & l) != 0L)
                      jjCheckNAddTwoStates(23, 24);
                   break;
                case 25:
                   if ((0x280000000000L & l) != 0L)
                      jjCheckNAdd(26);
                   break;
                case 26:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
                   if (kind > 9)
                      kind = 9;
                   jjCheckNAdd(26);
                   break;
                case 27:
                   if ((0x1800000000L & l) == 0L)
                      break;
                   if (kind > 51)
                      kind = 51;
                   jjCheckNAddTwoStates(28, 29);
                   break;
                case 28:
                   if ((0x3ff001000000000L & l) == 0L)
                      break;
                   if (kind > 51)
                      kind = 51;
                   jjCheckNAdd(28);
                   break;
                case 29:
                   if ((0x3ff001000000000L & l) == 0L)
                      break;
                   if (kind > 52)
                      kind = 52;
                   jjCheckNAdd(29);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else if ( < 128)
       {
          long l = 1L << ( & 077);
          do
          {
             switch([--i])
             {
                case 0:
                   if ((0x7fffffe87fffffeL & l) == 0L)
                      break;
                   if (kind > 51)
                      kind = 51;
                   jjCheckNAddTwoStates(28, 29);
                   break;
                case 30:
                   if ((0x7fffffe87fffffeL & l) != 0L)
                   {
                      if (kind > 52)
                         kind = 52;
                      jjCheckNAdd(29);
                   }
                   if ((0x7fffffe87fffffeL & l) != 0L)
                   {
                      if (kind > 51)
                         kind = 51;
                      jjCheckNAdd(28);
                   }
                   break;
                case 2:
                   if ((0x2000000020L & l) != 0L)
                      jjAddStates(29, 30);
                   break;
                case 6:
                   if ((0xffffffffefffffffL & l) != 0L)
                      jjCheckNAddStates(26, 28);
                   break;
                case 7:
                   if ( == 92)
                      [++] = 8;
                   break;
                case 8:
                   if ( == 92)
                      jjCheckNAddStates(26, 28);
                   break;
                case 11:
                   if ((0xffffffffefffffffL & l) != 0L)
                      jjCheckNAddStates(23, 25);
                   break;
                case 12:
                   if ( == 92)
                      [++] = 13;
                   break;
                case 13:
                   if ( == 92)
                      jjCheckNAddStates(23, 25);
                   break;
                case 20:
                   if ((0x2000000020L & l) != 0L)
                      jjAddStates(31, 32);
                   break;
                case 24:
                   if ((0x2000000020L & l) != 0L)
                      jjAddStates(33, 34);
                   break;
                case 28:
                   if ((0x7fffffe87fffffeL & l) == 0L)
                      break;
                   if (kind > 51)
                      kind = 51;
                   jjCheckNAdd(28);
                   break;
                case 29:
                   if ((0x7fffffe87fffffeL & l) == 0L)
                      break;
                   if (kind > 52)
                      kind = 52;
                   jjCheckNAdd(29);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else
       {
          int hiByte = (int)( >> 8);
          int i1 = hiByte >> 6;
          long l1 = 1L << (hiByte & 077);
          int i2 = ( & 0xff) >> 6;
          long l2 = 1L << ( & 077);
          do
          {
             switch([--i])
             {
                case 0:
                   if (!jjCanMove_1(hiBytei1i2l1l2))
                      break;
                   if (kind > 51)
                      kind = 51;
                   jjCheckNAddTwoStates(28, 29);
                   break;
                case 30:
                   if (jjCanMove_1(hiBytei1i2l1l2))
                   {
                      if (kind > 51)
                         kind = 51;
                      jjCheckNAdd(28);
                   }
                   if (jjCanMove_1(hiBytei1i2l1l2))
                   {
                      if (kind > 52)
                         kind = 52;
                      jjCheckNAdd(29);
                   }
                   break;
                case 6:
                   if (jjCanMove_0(hiBytei1i2l1l2))
                     jjAddStates(26, 28);
                  break;
               case 11:
                  if (jjCanMove_0(hiBytei1i2l1l2))
                     jjAddStates(23, 25);
                  break;
               case 28:
                  if (!jjCanMove_1(hiBytei1i2l1l2))
                     break;
                  if (kind > 51)
                     kind = 51;
                  jjCheckNAdd(28);
                  break;
               case 29:
                  if (!jjCanMove_1(hiBytei1i2l1l2))
                     break;
                  if (kind > 52)
                     kind = 52;
                  jjCheckNAdd(29);
                  break;
               default : break;
            }
         } while(i != startsAt);
      }
      if (kind != 0x7fffffff)
      {
          = kind;
          = curPos;
         kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = ) == (startsAt = 30 - ( = startsAt)))
         return curPos;
      try {  = .readChar(); }
      catch(java.io.IOException e) { return curPos; }
   }
static final int[] jjnextStates = {
   0, 1, 3, 4, 2, 0, 1, 4, 2, 0, 1, 4, 5, 2, 0, 1,
   2, 6, 16, 17, 18, 23, 24, 11, 12, 14, 6, 7, 9, 3, 4, 21,
   22, 25, 26,
private static final boolean jjCanMove_0(int hiByteint i1int i2long l1long l2)
   switch(hiByte)
   {
      case 0:
         return (([i2] & l2) != 0L);
      default :
         if (([i1] & l1) != 0L)
            return true;
         return false;
   }
private static final boolean jjCanMove_1(int hiByteint i1int i2long l1long l2)
   switch(hiByte)
   {
      case 0:
         return (([i2] & l2) != 0L);
      case 48:
         return (([i2] & l2) != 0L);
      case 49:
         return (([i2] & l2) != 0L);
      case 51:
         return (([i2] & l2) != 0L);
      case 61:
         return (([i2] & l2) != 0L);
      default :
         if (([i1] & l1) != 0L)
            return true;
         return false;
   }
Token literal values.
public static final String[] jjstrLiteralImages = {
""null"\44\173""\43\173"nullnullnullnullnullnullnullnull,
"\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,
nullnullnullnullnull, };

Lexer state names.
public static final String[] lexStateNames = {
   "DEFAULT",
   "IN_EXPRESSION",
Lex State array.
public static final int[] jjnewLexState = {
   -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,
static final long[] jjtoToken = {
   0x11ffffffffffb0fL,
static final long[] jjtoSkip = {
   0xf0L,
private final int[] jjrounds = new int[30];
private final int[] jjstateSet = new int[60];
protected char curChar;
Constructor.
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
    = stream;
Constructor.
public ELParserTokenManager(SimpleCharStream streamint lexState){
   this(stream);
   SwitchTo(lexState);
Reinitialise parser.
public void ReInit(SimpleCharStream stream)
    = stream;
private void ReInitRounds()
   int i;
    = 0x80000001;
   for (i = 30; i-- > 0;)
      [i] = 0x80000000;
Reinitialise parser.
public void ReInit(SimpleCharStream streamint lexState)
   ReInit(stream);
   SwitchTo(lexState);
Switch to specified lex state.
public void SwitchTo(int lexState)
   if (lexState >= 2 || lexState < 0)
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.".);
   else
       = lexState;
protected Token jjFillToken()
   final Token t;
   final String curTokenImage;
   final int beginLine;
   final int endLine;
   final int beginColumn;
   final int endColumn;
   curTokenImage = (im == null) ? .GetImage() : im;
   beginLine = .getBeginLine();
   beginColumn = .getBeginColumn();
   endLine = .getEndLine();
   endColumn = .getEndColumn();
   t = Token.newToken(curTokenImage);
   t.beginLine = beginLine;
   t.endLine = endLine;
   t.beginColumn = beginColumn;
   t.endColumn = endColumn;