home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / html32TokenManager.java < prev    next >
Text File  |  1998-02-26  |  67KB  |  2,042 lines
  1. /* Generated By:JavaCC: Do not edit this line. html32TokenManager.java */
  2. /*
  3.  * @(#)html-3.2.jj    1.18 97/12/03
  4.  * 
  5.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  6.  * 
  7.  * This software is the confidential and proprietary information of Sun
  8.  * Microsystems, Inc. ("Confidential Information").  You shall not
  9.  * disclose such Confidential Information and shall use it only in
  10.  * accordance with the terms of the license agreement you entered into
  11.  * with Sun.
  12.  * 
  13.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  14.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  15.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  16.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  17.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  18.  * THIS SOFTWARE OR ITS DERIVATIVES.
  19.  * 
  20.  */
  21.  
  22.  /*
  23.  * @version    1.18 12/03/97
  24.  * @author      Makarand Gokhale
  25.  */
  26. package com.sun.java.swing.text.html;
  27. /**
  28.  * An HTML parser class, derived from the grammar shipped
  29.  * with JavaCC.  This must be built with the -NOSTATIC option
  30.  * Add the appropriate callback to do the actions using HTMLParserCallback
  31.  * Interface. By Default this will do nothing
  32.  *
  33.  * The productions call into a method to deal with the action.
  34.  * These methods are called XXXAction where XXX is the name of
  35.  * the production.  This allows the grammer to be used for
  36.  * multiple things without a maintenance burdon.
  37.  * 
  38.  * @version    1.18 12/03/97
  39.  * @author      Makarand Gokhale
  40.  * @author      Timothy Prinzing
  41.  */
  42.  
  43. import java.net.*;
  44. import java.io.*;
  45.  
  46. class html32TokenManager implements html32Constants
  47. {
  48. private final int jjMoveStringLiteralDfa0_3()
  49. {
  50.    return jjMoveNfa_3(0, 0);
  51. }
  52. private final void jjCheckNAdd(int state)
  53. {
  54.    if (jjrounds[state] != jjround)
  55.    {
  56.       jjstateSet[jjnewStateCnt++] = state;
  57.       jjrounds[state] = jjround;
  58.    }
  59. }
  60. private final void jjAddStates(int start, int end)
  61. {
  62.    do {
  63.       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  64.    } while (start++ != end);
  65. }
  66. private final void jjCheckNAddTwoStates(int state1, int state2)
  67. {
  68.    jjCheckNAdd(state1);
  69.    jjCheckNAdd(state2);
  70. }
  71. private final void jjCheckNAddStates(int start, int end)
  72. {
  73.    do {
  74.       jjCheckNAdd(jjnextStates[start]);
  75.    } while (start++ != end);
  76. }
  77. static final long[] jjbitVec0 = {
  78.    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  79. };
  80. private final int jjMoveNfa_3(int startState, int curPos)
  81. {
  82.    int[] nextStates;
  83.    int startsAt = 0;
  84.    jjnewStateCnt = 8;
  85.    int i = 1;
  86.    jjstateSet[0] = startState;
  87.    int j, kind = 0x7fffffff;
  88.    for (;;)
  89.    {
  90.       if (++jjround == 0x7fffffff)
  91.          ReInitRounds();
  92.       if (curChar < 64)
  93.       {
  94.          long l = 1L << curChar;
  95.          MatchLoop: do
  96.          {
  97.             switch(jjstateSet[--i])
  98.             {
  99.                case 0:
  100.                   if ((0xbfffff7affffd9ffL & l) != 0L)
  101.                   {
  102.                      if (kind > 89)
  103.                         kind = 89;
  104.                      jjCheckNAdd(7);
  105.                   }
  106.                   else if ((0x100002600L & l) != 0L)
  107.                   {
  108.                      if (kind > 88)
  109.                         kind = 88;
  110.                   }
  111.                   else if (curChar == 34)
  112.                      jjCheckNAdd(5);
  113.                   else if (curChar == 39)
  114.                      jjCheckNAdd(2);
  115.                   break;
  116.                case 5:
  117.                   if ((0xfffffffbffffffffL & l) != 0L)
  118.                      jjCheckNAddTwoStates(5, 6);
  119.                   else if (curChar == 34)
  120.                   {
  121.                      if (kind > 89)
  122.                         kind = 89;
  123.                   }
  124.                   break;
  125.                case 2:
  126.                   if ((0xffffff7fffffffffL & l) != 0L)
  127.                      jjCheckNAddTwoStates(2, 3);
  128.                   else if (curChar == 39)
  129.                   {
  130.                      if (kind > 89)
  131.                         kind = 89;
  132.                   }
  133.                   break;
  134.                case 1:
  135.                   if (curChar == 39)
  136.                      jjCheckNAdd(2);
  137.                   break;
  138.                case 4:
  139.                   if (curChar == 34)
  140.                      jjCheckNAdd(5);
  141.                   break;
  142.                case 7:
  143.                   if ((0xbfffff7affffd9ffL & l) == 0L)
  144.                      break;
  145.                   if (kind > 89)
  146.                      kind = 89;
  147.                   jjCheckNAdd(7);
  148.                   break;
  149.                default : break;
  150.             }
  151.          } while(i != startsAt);
  152.       }
  153.       else if (curChar < 128)
  154.       {
  155.          long l = 1L << (curChar & 077);
  156.          MatchLoop: do
  157.          {
  158.             switch(jjstateSet[--i])
  159.             {
  160.                case 0:
  161.                case 7:
  162.                   if (kind > 89)
  163.                      kind = 89;
  164.                   jjCheckNAdd(7);
  165.                   break;
  166.                case 5:
  167.                   jjCheckNAddTwoStates(5, 6);
  168.                   break;
  169.                case 2:
  170.                   jjCheckNAddTwoStates(2, 3);
  171.                   break;
  172.                default : break;
  173.             }
  174.          } while(i != startsAt);
  175.       }
  176.       else
  177.       {
  178.          int i2 = (curChar & 0xff) >> 6;
  179.          long l2 = 1L << (curChar & 077);
  180.          MatchLoop: do
  181.          {
  182.             switch(jjstateSet[--i])
  183.             {
  184.                case 0:
  185.                case 7:
  186.                   if ((jjbitVec0[i2] & l2) == 0L)
  187.                      break;
  188.                   if (kind > 89)
  189.                      kind = 89;
  190.                   jjCheckNAdd(7);
  191.                   break;
  192.                case 5:
  193.                   if ((jjbitVec0[i2] & l2) != 0L)
  194.                      jjCheckNAddTwoStates(5, 6);
  195.                   break;
  196.                case 2:
  197.                   if ((jjbitVec0[i2] & l2) != 0L)
  198.                      jjCheckNAddTwoStates(2, 3);
  199.                   break;
  200.                default : break;
  201.             }
  202.          } while(i != startsAt);
  203.       }
  204.       if (kind != 0x7fffffff)
  205.       {
  206.          jjmatchedKind = kind;
  207.          jjmatchedPos = curPos;
  208.          kind = 0x7fffffff;
  209.       }
  210.       ++curPos;
  211.       if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
  212.          return curPos;
  213.       try { curChar = input_stream.readChar(); }
  214.       catch(java.io.IOException e) { return curPos; }
  215.    }
  216. }
  217. private final int jjStopStringLiteralDfa_0(int pos, long active0)
  218. {
  219.    switch (pos)
  220.    {
  221.       case 0:
  222.          if ((active0 & 0x20L) != 0L)
  223.          {
  224.             jjmatchedKind = 4;
  225.             return 3;
  226.          }
  227.          return -1;
  228.       default :
  229.          return -1;
  230.    }
  231. }
  232. private final int jjStartNfa_0(int pos, long active0)
  233. {
  234.    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  235. }
  236. private final int jjStopAtPos(int pos, int kind)
  237. {
  238.    jjmatchedKind = kind;
  239.    jjmatchedPos = pos;
  240.    return pos + 1;
  241. }
  242. private final int jjStartNfaWithStates_0(int pos, int kind, int state)
  243. {
  244.    jjmatchedKind = kind;
  245.    jjmatchedPos = pos;
  246.    try { curChar = input_stream.readChar(); }
  247.    catch(java.io.IOException e) { return pos + 1; }
  248.    return jjMoveNfa_0(state, pos + 1);
  249. }
  250. private final int jjMoveStringLiteralDfa0_0()
  251. {
  252.    switch(curChar)
  253.    {
  254.       case 60:
  255.          return jjMoveStringLiteralDfa1_0(0x20L);
  256.       default :
  257.          return jjMoveNfa_0(2, 0);
  258.    }
  259. }
  260. private final int jjMoveStringLiteralDfa1_0(long active0)
  261. {
  262.    try { curChar = input_stream.readChar(); }
  263.    catch(java.io.IOException e) {
  264.       jjStopStringLiteralDfa_0(0, active0);
  265.       return 1;
  266.    }
  267.    switch(curChar)
  268.    {
  269.       case 47:
  270.          if ((active0 & 0x20L) != 0L)
  271.             return jjStopAtPos(1, 5);
  272.          break;
  273.       default :
  274.          break;
  275.    }
  276.    return jjStartNfa_0(0, active0);
  277. }
  278. private final int jjMoveNfa_0(int startState, int curPos)
  279. {
  280.    int[] nextStates;
  281.    int startsAt = 0;
  282.    jjnewStateCnt = 16;
  283.    int i = 1;
  284.    jjstateSet[0] = startState;
  285.    int j, kind = 0x7fffffff;
  286.    for (;;)
  287.    {
  288.       if (++jjround == 0x7fffffff)
  289.          ReInitRounds();
  290.       if (curChar < 64)
  291.       {
  292.          long l = 1L << curChar;
  293.          MatchLoop: do
  294.          {
  295.             switch(jjstateSet[--i])
  296.             {
  297.                case 3:
  298.                   if ((0x7000000100000000L & l) != 0L)
  299.                      jjCheckNAdd(15);
  300.                   else if (curChar == 33)
  301.                      jjCheckNAdd(7);
  302.                   if ((0x100002600L & l) != 0L)
  303.                      jjCheckNAdd(12);
  304.                   else if (curChar == 33)
  305.                      jjCheckNAdd(4);
  306.                   break;
  307.                case 9:
  308.                   if ((0xafffffffffffffffL & l) != 0L)
  309.                      jjCheckNAdd(9);
  310.                   else if (curChar == 62)
  311.                   {
  312.                      if (kind > 2)
  313.                         kind = 2;
  314.                   }
  315.                   break;
  316.                case 7:
  317.                   if ((0xbfffffffffffffffL & l) != 0L)
  318.                      jjCheckNAdd(7);
  319.                   else if (curChar == 62)
  320.                      jjCheckNAdd(9);
  321.                   break;
  322.                case 13:
  323.                   if ((0x100002600L & l) != 0L)
  324.                      jjCheckNAdd(12);
  325.                   else if (curChar == 60)
  326.                   {
  327.                      if (kind > 4)
  328.                         kind = 4;
  329.                   }
  330.                   break;
  331.                case 4:
  332.                   if ((0xbfffffffffffffffL & l) != 0L)
  333.                      jjCheckNAdd(4);
  334.                   else if (curChar == 62)
  335.                   {
  336.                      if (kind > 1)
  337.                         kind = 1;
  338.                   }
  339.                   break;
  340.                case 2:
  341.                   if ((0xefffffffffffffffL & l) != 0L)
  342.                   {
  343.                      if (kind > 6)
  344.                         kind = 6;
  345.                      jjCheckNAdd(1);
  346.                   }
  347.                   else if (curChar == 60)
  348.                   {
  349.                      if (kind > 4)
  350.                         kind = 4;
  351.                      jjCheckNAddTwoStates(12, 14);
  352.                   }
  353.                   if ((0x100002600L & l) != 0L)
  354.                   {
  355.                      if (kind > 3)
  356.                         kind = 3;
  357.                      jjCheckNAdd(0);
  358.                   }
  359.                   else if (curChar == 60)
  360.                      jjAddStates(0, 1);
  361.                   break;
  362.                case 0:
  363.                   if ((0x100002600L & l) == 0L)
  364.                      break;
  365.                   if (kind > 3)
  366.                      kind = 3;
  367.                   jjCheckNAdd(0);
  368.                   break;
  369.                case 1:
  370.                   if ((0xefffffffffffffffL & l) == 0L)
  371.                      break;
  372.                   if (kind > 6)
  373.                      kind = 6;
  374.                   jjCheckNAdd(1);
  375.                   break;
  376.                case 6:
  377.                   if (curChar == 33)
  378.                      jjCheckNAdd(7);
  379.                   break;
  380.                case 11:
  381.                   if (curChar != 60)
  382.                      break;
  383.                   if (kind > 4)
  384.                      kind = 4;
  385.                   jjCheckNAddTwoStates(12, 14);
  386.                   break;
  387.                case 14:
  388.                   if ((0x7000000100000000L & l) != 0L)
  389.                      jjCheckNAdd(15);
  390.                   break;
  391.                case 15:
  392.                   if ((0xefffffffffffffffL & l) == 0L)
  393.                      break;
  394.                   if (kind > 6)
  395.                      kind = 6;
  396.                   jjCheckNAdd(15);
  397.                   break;
  398.                default : break;
  399.             }
  400.          } while(i != startsAt);
  401.       }
  402.       else if (curChar < 128)
  403.       {
  404.          long l = 1L << (curChar & 077);
  405.          MatchLoop: do
  406.          {
  407.             switch(jjstateSet[--i])
  408.             {
  409.                case 9:
  410.                   jjCheckNAdd(9);
  411.                   break;
  412.                case 7:
  413.                   jjCheckNAdd(7);
  414.                   break;
  415.                case 4:
  416.                   jjCheckNAdd(4);
  417.                   break;
  418.                case 2:
  419.                case 1:
  420.                   if (kind > 6)
  421.                      kind = 6;
  422.                   jjCheckNAdd(1);
  423.                   break;
  424.                case 15:
  425.                   if (kind > 6)
  426.                      kind = 6;
  427.                   jjstateSet[jjnewStateCnt++] = 15;
  428.                   break;
  429.                default : break;
  430.             }
  431.          } while(i != startsAt);
  432.       }
  433.       else
  434.       {
  435.          int i2 = (curChar & 0xff) >> 6;
  436.          long l2 = 1L << (curChar & 077);
  437.          MatchLoop: do
  438.          {
  439.             switch(jjstateSet[--i])
  440.             {
  441.                case 9:
  442.                   if ((jjbitVec0[i2] & l2) != 0L)
  443.                      jjCheckNAdd(9);
  444.                   break;
  445.                case 7:
  446.                   if ((jjbitVec0[i2] & l2) != 0L)
  447.                      jjCheckNAdd(7);
  448.                   break;
  449.                case 4:
  450.                   if ((jjbitVec0[i2] & l2) != 0L)
  451.                      jjCheckNAdd(4);
  452.                   break;
  453.                case 2:
  454.                case 1:
  455.                   if ((jjbitVec0[i2] & l2) == 0L)
  456.                      break;
  457.                   if (kind > 6)
  458.                      kind = 6;
  459.                   jjCheckNAdd(1);
  460.                   break;
  461.                case 15:
  462.                   if ((jjbitVec0[i2] & l2) == 0L)
  463.                      break;
  464.                   if (kind > 6)
  465.                      kind = 6;
  466.                   jjstateSet[jjnewStateCnt++] = 15;
  467.                   break;
  468.                default : break;
  469.             }
  470.          } while(i != startsAt);
  471.       }
  472.       if (kind != 0x7fffffff)
  473.       {
  474.          jjmatchedKind = kind;
  475.          jjmatchedPos = curPos;
  476.          kind = 0x7fffffff;
  477.       }
  478.       ++curPos;
  479.       if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
  480.          return curPos;
  481.       try { curChar = input_stream.readChar(); }
  482.       catch(java.io.IOException e) { return curPos; }
  483.    }
  484. }
  485. private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1)
  486. {
  487.    switch (pos)
  488.    {
  489.       case 0:
  490.          if ((active1 & 0x10000000L) != 0L)
  491.             return 2;
  492.          return -1;
  493.       default :
  494.          return -1;
  495.    }
  496. }
  497. private final int jjStartNfa_4(int pos, long active0, long active1)
  498. {
  499.    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1), pos + 1);
  500. }
  501. private final int jjStartNfaWithStates_4(int pos, int kind, int state)
  502. {
  503.    jjmatchedKind = kind;
  504.    jjmatchedPos = pos;
  505.    try { curChar = input_stream.readChar(); }
  506.    catch(java.io.IOException e) { return pos + 1; }
  507.    return jjMoveNfa_4(state, pos + 1);
  508. }
  509. private final int jjMoveStringLiteralDfa0_4()
  510. {
  511.    switch(curChar)
  512.    {
  513.       case 45:
  514.          return jjMoveStringLiteralDfa1_4(0x10000000L);
  515.       default :
  516.          return jjMoveNfa_4(1, 0);
  517.    }
  518. }
  519. private final int jjMoveStringLiteralDfa1_4(long active1)
  520. {
  521.    try { curChar = input_stream.readChar(); }
  522.    catch(java.io.IOException e) {
  523.       jjStopStringLiteralDfa_4(0, 0L, active1);
  524.       return 1;
  525.    }
  526.    switch(curChar)
  527.    {
  528.       case 45:
  529.          if ((active1 & 0x10000000L) != 0L)
  530.             return jjStopAtPos(1, 92);
  531.          break;
  532.       default :
  533.          break;
  534.    }
  535.    return jjStartNfa_4(0, 0L, active1);
  536. }
  537. private final int jjMoveNfa_4(int startState, int curPos)
  538. {
  539.    int[] nextStates;
  540.    int startsAt = 0;
  541.    jjnewStateCnt = 3;
  542.    int i = 1;
  543.    jjstateSet[0] = startState;
  544.    int j, kind = 0x7fffffff;
  545.    for (;;)
  546.    {
  547.       if (++jjround == 0x7fffffff)
  548.          ReInitRounds();
  549.       if (curChar < 64)
  550.       {
  551.          long l = 1L << curChar;
  552.          MatchLoop: do
  553.          {
  554.             switch(jjstateSet[--i])
  555.             {
  556.                case 1:
  557.                   if ((0xffffdfffffffffffL & l) != 0L)
  558.                   {
  559.                      if (kind > 90)
  560.                         kind = 90;
  561.                      jjCheckNAdd(0);
  562.                   }
  563.                   else if (curChar == 45)
  564.                      jjCheckNAdd(2);
  565.                   break;
  566.                case 0:
  567.                   if ((0xffffdfffffffffffL & l) == 0L)
  568.                      break;
  569.                   if (kind > 90)
  570.                      kind = 90;
  571.                   jjCheckNAdd(0);
  572.                   break;
  573.                case 2:
  574.                   if ((0xffffdfffffffffffL & l) == 0L)
  575.                      break;
  576.                   if (kind > 91)
  577.                      kind = 91;
  578.                   jjCheckNAdd(2);
  579.                   break;
  580.                default : break;
  581.             }
  582.          } while(i != startsAt);
  583.       }
  584.       else if (curChar < 128)
  585.       {
  586.          long l = 1L << (curChar & 077);
  587.          MatchLoop: do
  588.          {
  589.             switch(jjstateSet[--i])
  590.             {
  591.                case 1:
  592.                case 0:
  593.                   if (kind > 90)
  594.                      kind = 90;
  595.                   jjCheckNAdd(0);
  596.                   break;
  597.                case 2:
  598.                   if (kind > 91)
  599.                      kind = 91;
  600.                   jjstateSet[jjnewStateCnt++] = 2;
  601.                   break;
  602.                default : break;
  603.             }
  604.          } while(i != startsAt);
  605.       }
  606.       else
  607.       {
  608.          int i2 = (curChar & 0xff) >> 6;
  609.          long l2 = 1L << (curChar & 077);
  610.          MatchLoop: do
  611.          {
  612.             switch(jjstateSet[--i])
  613.             {
  614.                case 1:
  615.                case 0:
  616.                   if ((jjbitVec0[i2] & l2) == 0L)
  617.                      break;
  618.                   if (kind > 90)
  619.                      kind = 90;
  620.                   jjCheckNAdd(0);
  621.                   break;
  622.                case 2:
  623.                   if ((jjbitVec0[i2] & l2) == 0L)
  624.                      break;
  625.                   if (kind > 91)
  626.                      kind = 91;
  627.                   jjstateSet[jjnewStateCnt++] = 2;
  628.                   break;
  629.                default : break;
  630.             }
  631.          } while(i != startsAt);
  632.       }
  633.       if (kind != 0x7fffffff)
  634.       {
  635.          jjmatchedKind = kind;
  636.          jjmatchedPos = curPos;
  637.          kind = 0x7fffffff;
  638.       }
  639.       ++curPos;
  640.       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
  641.          return curPos;
  642.       try { curChar = input_stream.readChar(); }
  643.       catch(java.io.IOException e) { return curPos; }
  644.    }
  645. }
  646. private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
  647. {
  648.    switch (pos)
  649.    {
  650.       case 0:
  651.          if ((active1 & 0x8000L) != 0L)
  652.          {
  653.             jjmatchedKind = 85;
  654.             return 3;
  655.          }
  656.          return -1;
  657.       default :
  658.          return -1;
  659.    }
  660. }
  661. private final int jjStartNfa_2(int pos, long active0, long active1)
  662. {
  663.    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
  664. }
  665. private final int jjStartNfaWithStates_2(int pos, int kind, int state)
  666. {
  667.    jjmatchedKind = kind;
  668.    jjmatchedPos = pos;
  669.    try { curChar = input_stream.readChar(); }
  670.    catch(java.io.IOException e) { return pos + 1; }
  671.    return jjMoveNfa_2(state, pos + 1);
  672. }
  673. private final int jjMoveStringLiteralDfa0_2()
  674. {
  675.    switch(curChar)
  676.    {
  677.       case 45:
  678.          return jjMoveStringLiteralDfa1_2(0x8000L);
  679.       case 60:
  680.          jjmatchedKind = 87;
  681.          return jjMoveStringLiteralDfa1_2(0x400000L);
  682.       case 61:
  683.          return jjStopAtPos(0, 81);
  684.       case 62:
  685.          return jjStopAtPos(0, 80);
  686.       default :
  687.          return jjMoveNfa_2(2, 0);
  688.    }
  689. }
  690. private final int jjMoveStringLiteralDfa1_2(long active1)
  691. {
  692.    try { curChar = input_stream.readChar(); }
  693.    catch(java.io.IOException e) {
  694.       jjStopStringLiteralDfa_2(0, 0L, active1);
  695.       return 1;
  696.    }
  697.    switch(curChar)
  698.    {
  699.       case 45:
  700.          if ((active1 & 0x8000L) != 0L)
  701.             return jjStartNfaWithStates_2(1, 79, 3);
  702.          break;
  703.       case 47:
  704.          if ((active1 & 0x400000L) != 0L)
  705.             return jjStopAtPos(1, 86);
  706.          break;
  707.       default :
  708.          break;
  709.    }
  710.    return jjStartNfa_2(0, 0L, active1);
  711. }
  712. private final int jjMoveNfa_2(int startState, int curPos)
  713. {
  714.    int[] nextStates;
  715.    int startsAt = 0;
  716.    jjnewStateCnt = 4;
  717.    int i = 1;
  718.    jjstateSet[0] = startState;
  719.    int j, kind = 0x7fffffff;
  720.    for (;;)
  721.    {
  722.       if (++jjround == 0x7fffffff)
  723.          ReInitRounds();
  724.       if (curChar < 64)
  725.       {
  726.          long l = 1L << curChar;
  727.          MatchLoop: do
  728.          {
  729.             switch(jjstateSet[--i])
  730.             {
  731.                case 2:
  732.                   if ((0x8c001fffffffffffL & l) != 0L)
  733.                   {
  734.                      if (kind > 78)
  735.                         kind = 78;
  736.                      jjCheckNAdd(1);
  737.                   }
  738.                   else if ((0x600000000000L & l) != 0L)
  739.                   {
  740.                      if (kind > 85)
  741.                         kind = 85;
  742.                      jjCheckNAdd(3);
  743.                   }
  744.                   if ((0x100002600L & l) != 0L)
  745.                   {
  746.                      if (kind > 77)
  747.                         kind = 77;
  748.                      jjCheckNAdd(0);
  749.                   }
  750.                   break;
  751.                case 0:
  752.                   if ((0x100002600L & l) == 0L)
  753.                      break;
  754.                   if (kind > 77)
  755.                      kind = 77;
  756.                   jjCheckNAdd(0);
  757.                   break;
  758.                case 1:
  759.                   if ((0x8c001fffffffffffL & l) == 0L)
  760.                      break;
  761.                   if (kind > 78)
  762.                      kind = 78;
  763.                   jjCheckNAdd(1);
  764.                   break;
  765.                case 3:
  766.                   if ((0x3ff600000000000L & l) == 0L)
  767.                      break;
  768.                   if (kind > 85)
  769.                      kind = 85;
  770.                   jjCheckNAdd(3);
  771.                   break;
  772.                default : break;
  773.             }
  774.          } while(i != startsAt);
  775.       }
  776.       else if (curChar < 128)
  777.       {
  778.          long l = 1L << (curChar & 077);
  779.          MatchLoop: do
  780.          {
  781.             switch(jjstateSet[--i])
  782.             {
  783.                case 2:
  784.                   if ((0x7fffffe87fffffeL & l) != 0L)
  785.                   {
  786.                      if (kind > 85)
  787.                         kind = 85;
  788.                      jjCheckNAdd(3);
  789.                   }
  790.                   else if ((0xf800000178000001L & l) != 0L)
  791.                   {
  792.                      if (kind > 78)
  793.                         kind = 78;
  794.                      jjCheckNAdd(1);
  795.                   }
  796.                   break;
  797.                case 1:
  798.                   if ((0xf800000178000001L & l) == 0L)
  799.                      break;
  800.                   kind = 78;
  801.                   jjstateSet[jjnewStateCnt++] = 1;
  802.                   break;
  803.                case 3:
  804.                   if ((0x7fffffe87fffffeL & l) == 0L)
  805.                      break;
  806.                   if (kind > 85)
  807.                      kind = 85;
  808.                   jjCheckNAdd(3);
  809.                   break;
  810.                default : break;
  811.             }
  812.          } while(i != startsAt);
  813.       }
  814.       else
  815.       {
  816.          int i2 = (curChar & 0xff) >> 6;
  817.          long l2 = 1L << (curChar & 077);
  818.          MatchLoop: do
  819.          {
  820.             switch(jjstateSet[--i])
  821.             {
  822.                case 2:
  823.                case 1:
  824.                   if ((jjbitVec0[i2] & l2) == 0L)
  825.                      break;
  826.                   if (kind > 78)
  827.                      kind = 78;
  828.                   jjCheckNAdd(1);
  829.                   break;
  830.                default : break;
  831.             }
  832.          } while(i != startsAt);
  833.       }
  834.       if (kind != 0x7fffffff)
  835.       {
  836.          jjmatchedKind = kind;
  837.          jjmatchedPos = curPos;
  838.          kind = 0x7fffffff;
  839.       }
  840.       ++curPos;
  841.       if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
  842.          return curPos;
  843.       try { curChar = input_stream.readChar(); }
  844.       catch(java.io.IOException e) { return curPos; }
  845.    }
  846. }
  847. private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
  848. {
  849.    switch (pos)
  850.    {
  851.       case 0:
  852.          if ((active0 & 0xfff00f000003ff80L) != 0L || (active1 & 0x603L) != 0L)
  853.             return 0;
  854.          if ((active0 & 0xff0fffffc0000L) != 0L || (active1 & 0x9fcL) != 0L)
  855.          {
  856.             jjmatchedKind = 76;
  857.             return 0;
  858.          }
  859.          return -1;
  860.       case 1:
  861.          if ((active0 & 0x4605f9c420000L) != 0L || (active1 & 0x5a8L) != 0L)
  862.             return 0;
  863.          if ((active0 & 0xdfeb9ea063bdf700L) != 0L || (active1 & 0x857L) != 0L)
  864.          {
  865.             if (jjmatchedPos != 1)
  866.             {
  867.                jjmatchedKind = 76;
  868.                jjmatchedPos = 1;
  869.             }
  870.             return 0;
  871.          }
  872.          return -1;
  873.       case 2:
  874.          if ((active0 & 0xdfab4ca0603db700L) != 0L || (active1 & 0x54L) != 0L)
  875.          {
  876.             jjmatchedKind = 76;
  877.             jjmatchedPos = 2;
  878.             return 0;
  879.          }
  880.          if ((active0 & 0x40920003804000L) != 0L || (active1 & 0x803L) != 0L)
  881.             return 0;
  882.          return -1;
  883.       case 3:
  884.          if ((active0 & 0xdea80c00000c8300L) != 0L || (active1 & 0x54L) != 0L)
  885.          {
  886.             if (jjmatchedPos != 3)
  887.             {
  888.                jjmatchedKind = 76;
  889.                jjmatchedPos = 3;
  890.             }
  891.             return 0;
  892.          }
  893.          if ((active0 & 0x10340a060313400L) != 0L)
  894.             return 0;
  895.          return -1;
  896.       case 4:
  897.          if ((active0 & 0x8820040000000000L) != 0L || (active1 & 0x44L) != 0L)
  898.             return 0;
  899.          if ((active0 & 0x56880800000ca300L) != 0L || (active1 & 0x10L) != 0L)
  900.          {
  901.             jjmatchedKind = 76;
  902.             jjmatchedPos = 4;
  903.             return 0;
  904.          }
  905.          return -1;
  906.       case 5:
  907.          if ((active0 & 0x5688000000080200L) != 0L)
  908.             return 0;
  909.          if ((active0 & 0x8000004a100L) != 0L || (active1 & 0x10L) != 0L)
  910.          {
  911.             jjmatchedKind = 76;
  912.             jjmatchedPos = 5;
  913.             return 0;
  914.          }
  915.          return -1;
  916.       case 6:
  917.          if ((active0 & 0xa000L) != 0L || (active1 & 0x10L) != 0L)
  918.          {
  919.             jjmatchedKind = 76;
  920.             jjmatchedPos = 6;
  921.             return 0;
  922.          }
  923.          if ((active0 & 0x80000040100L) != 0L)
  924.             return 0;
  925.          return -1;
  926.       case 7:
  927.          if ((active0 & 0x2000L) != 0L || (active1 & 0x10L) != 0L)
  928.             return 0;
  929.          if ((active0 & 0x8000L) != 0L)
  930.          {
  931.             jjmatchedKind = 76;
  932.             jjmatchedPos = 7;
  933.             return 0;
  934.          }
  935.          return -1;
  936.       case 8:
  937.          if ((active0 & 0x8000L) != 0L)
  938.          {
  939.             jjmatchedKind = 76;
  940.             jjmatchedPos = 8;
  941.             return 0;
  942.          }
  943.          return -1;
  944.       default :
  945.          return -1;
  946.    }
  947. }
  948. private final int jjStartNfa_1(int pos, long active0, long active1)
  949. {
  950.    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
  951. }
  952. private final int jjStartNfaWithStates_1(int pos, int kind, int state)
  953. {
  954.    jjmatchedKind = kind;
  955.    jjmatchedPos = pos;
  956.    try { curChar = input_stream.readChar(); }
  957.    catch(java.io.IOException e) { return pos + 1; }
  958.    return jjMoveNfa_1(state, pos + 1);
  959. }
  960. private final int jjMoveStringLiteralDfa0_1()
  961. {
  962.    switch(curChar)
  963.    {
  964.       case 65:
  965.          jjmatchedKind = 7;
  966.          return jjMoveStringLiteralDfa1_1(0x700L, 0x0L);
  967.       case 66:
  968.          jjmatchedKind = 11;
  969.          return jjMoveStringLiteralDfa1_1(0x3f000L, 0x0L);
  970.       case 67:
  971.          return jjMoveStringLiteralDfa1_1(0x3c0000L, 0x0L);
  972.       case 68:
  973.          return jjMoveStringLiteralDfa1_1(0xfc00000L, 0x0L);
  974.       case 69:
  975.          return jjMoveStringLiteralDfa1_1(0x10000000L, 0x0L);
  976.       case 70:
  977.          return jjMoveStringLiteralDfa1_1(0x60000000L, 0x0L);
  978.       case 72:
  979.          return jjMoveStringLiteralDfa1_1(0xff80000000L, 0x0L);
  980.       case 73:
  981.          jjmatchedKind = 40;
  982.          return jjMoveStringLiteralDfa1_1(0xe0000000000L, 0x0L);
  983.       case 75:
  984.          return jjMoveStringLiteralDfa1_1(0x100000000000L, 0x0L);
  985.       case 76:
  986.          return jjMoveStringLiteralDfa1_1(0x600000000000L, 0x0L);
  987.       case 77:
  988.          return jjMoveStringLiteralDfa1_1(0x3800000000000L, 0x0L);
  989.       case 79:
  990.          return jjMoveStringLiteralDfa1_1(0xc000000000000L, 0x0L);
  991.       case 80:
  992.          jjmatchedKind = 52;
  993.          return jjMoveStringLiteralDfa1_1(0xe0000000000000L, 0x0L);
  994.       case 83:
  995.          jjmatchedKind = 61;
  996.          return jjMoveStringLiteralDfa1_1(0xdf00000000000000L, 0x3L);
  997.       case 84:
  998.          return jjMoveStringLiteralDfa1_1(0x0L, 0x1fcL);
  999.       case 85:
  1000.          jjmatchedKind = 73;
  1001.          return jjMoveStringLiteralDfa1_1(0x0L, 0x400L);
  1002.       case 86:
  1003.          return jjMoveStringLiteralDfa1_1(0x0L, 0x800L);
  1004.       case 97:
  1005.          jjmatchedKind = 7;
  1006.          return jjMoveStringLiteralDfa1_1(0x700L, 0x0L);
  1007.       case 98:
  1008.          jjmatchedKind = 11;
  1009.          return jjMoveStringLiteralDfa1_1(0x3f000L, 0x0L);
  1010.       case 99:
  1011.          return jjMoveStringLiteralDfa1_1(0x3c0000L, 0x0L);
  1012.       case 100:
  1013.          return jjMoveStringLiteralDfa1_1(0xfc00000L, 0x0L);
  1014.       case 101:
  1015.          return jjMoveStringLiteralDfa1_1(0x10000000L, 0x0L);
  1016.       case 102:
  1017.          return jjMoveStringLiteralDfa1_1(0x60000000L, 0x0L);
  1018.       case 104:
  1019.          return jjMoveStringLiteralDfa1_1(0xff80000000L, 0x0L);
  1020.       case 105:
  1021.          jjmatchedKind = 40;
  1022.          return jjMoveStringLiteralDfa1_1(0xe0000000000L, 0x0L);
  1023.       case 107:
  1024.          return jjMoveStringLiteralDfa1_1(0x100000000000L, 0x0L);
  1025.       case 108:
  1026.          return jjMoveStringLiteralDfa1_1(0x600000000000L, 0x0L);
  1027.       case 109:
  1028.          return jjMoveStringLiteralDfa1_1(0x3800000000000L, 0x0L);
  1029.       case 111:
  1030.          return jjMoveStringLiteralDfa1_1(0xc000000000000L, 0x0L);
  1031.       case 112:
  1032.          jjmatchedKind = 52;
  1033.          return jjMoveStringLiteralDfa1_1(0xe0000000000000L, 0x0L);
  1034.       case 115:
  1035.          jjmatchedKind = 61;
  1036.          return jjMoveStringLiteralDfa1_1(0xdf00000000000000L, 0x3L);
  1037.       case 116:
  1038.          return jjMoveStringLiteralDfa1_1(0x0L, 0x1fcL);
  1039.       case 117:
  1040.          jjmatchedKind = 73;
  1041.          return jjMoveStringLiteralDfa1_1(0x0L, 0x400L);
  1042.       case 118:
  1043.          return jjMoveStringLiteralDfa1_1(0x0L, 0x800L);
  1044.       default :
  1045.          return jjMoveNfa_1(0, 0);
  1046.    }
  1047. }
  1048. private final int jjMoveStringLiteralDfa1_1(long active0, long active1)
  1049. {
  1050.    try { curChar = input_stream.readChar(); }
  1051.    catch(java.io.IOException e) {
  1052.       jjStopStringLiteralDfa_1(0, active0, active1);
  1053.       return 1;
  1054.    }
  1055.    switch(curChar)
  1056.    {
  1057.       case 49:
  1058.          if ((active0 & 0x80000000L) != 0L)
  1059.             return jjStartNfaWithStates_1(1, 31, 0);
  1060.          break;
  1061.       case 50:
  1062.          if ((active0 & 0x100000000L) != 0L)
  1063.             return jjStartNfaWithStates_1(1, 32, 0);
  1064.          break;
  1065.       case 51:
  1066.          if ((active0 & 0x200000000L) != 0L)
  1067.             return jjStartNfaWithStates_1(1, 33, 0);
  1068.          break;
  1069.       case 52:
  1070.          if ((active0 & 0x400000000L) != 0L)
  1071.             return jjStartNfaWithStates_1(1, 34, 0);
  1072.          break;
  1073.       case 53:
  1074.          if ((active0 & 0x800000000L) != 0L)
  1075.             return jjStartNfaWithStates_1(1, 35, 0);
  1076.          break;
  1077.       case 54:
  1078.          if ((active0 & 0x1000000000L) != 0L)
  1079.             return jjStartNfaWithStates_1(1, 36, 0);
  1080.          break;
  1081.       case 65:
  1082.          return jjMoveStringLiteralDfa2_1(active0, 0x120800000043000L, active1, 0x804L);
  1083.       case 66:
  1084.          return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L, active1, 0L);
  1085.       case 67:
  1086.          return jjMoveStringLiteralDfa2_1(active0, 0x200000000000000L, active1, 0L);
  1087.       case 68:
  1088.          if ((active0 & 0x400000L) != 0L)
  1089.             return jjStartNfaWithStates_1(1, 22, 0);
  1090.          else if ((active1 & 0x8L) != 0L)
  1091.             return jjStartNfaWithStates_1(1, 67, 0);
  1092.          return jjMoveStringLiteralDfa2_1(active0, 0x100L, active1, 0L);
  1093.       case 69:
  1094.          return jjMoveStringLiteralDfa2_1(active0, 0x403002000080000L, active1, 0x10L);
  1095.       case 70:
  1096.          return jjMoveStringLiteralDfa2_1(active0, 0x800000L, active1, 0L);
  1097.       case 72:
  1098.          if ((active1 & 0x20L) != 0L)
  1099.             return jjStartNfaWithStates_1(1, 69, 0);
  1100.          break;
  1101.       case 73:
  1102.          if ((active0 & 0x200000000000L) != 0L)
  1103.          {
  1104.             jjmatchedKind = 45;
  1105.             jjmatchedPos = 1;
  1106.          }
  1107.          return jjMoveStringLiteralDfa2_1(active0, 0x400003104000L, active1, 0x40L);
  1108.       case 76:
  1109.          if ((active0 & 0x4000000L) != 0L)
  1110.             return jjStartNfaWithStates_1(1, 26, 0);
  1111.          else if ((active0 & 0x4000000000000L) != 0L)
  1112.             return jjStartNfaWithStates_1(1, 50, 0);
  1113.          else if ((active1 & 0x400L) != 0L)
  1114.             return jjStartNfaWithStates_1(1, 74, 0);
  1115.          return jjMoveStringLiteralDfa2_1(active0, 0x8000L, active1, 0L);
  1116.       case 77:
  1117.          if ((active0 & 0x10000000L) != 0L)
  1118.             return jjStartNfaWithStates_1(1, 28, 0);
  1119.          return jjMoveStringLiteralDfa2_1(active0, 0x800020000000000L, active1, 0L);
  1120.       case 78:
  1121.          return jjMoveStringLiteralDfa2_1(active0, 0x40000000000L, active1, 0L);
  1122.       case 79:
  1123.          return jjMoveStringLiteralDfa2_1(active0, 0x60210000L, active1, 0L);
  1124.       case 80:
  1125.          return jjMoveStringLiteralDfa2_1(active0, 0x8000000000200L, active1, 0L);
  1126.       case 82:
  1127.          if ((active0 & 0x20000L) != 0L)
  1128.             return jjStartNfaWithStates_1(1, 17, 0);
  1129.          else if ((active0 & 0x4000000000L) != 0L)
  1130.             return jjStartNfaWithStates_1(1, 38, 0);
  1131.          else if ((active1 & 0x80L) != 0L)
  1132.             return jjStartNfaWithStates_1(1, 71, 0);
  1133.          return jjMoveStringLiteralDfa2_1(active0, 0xc0000000000400L, active1, 0L);
  1134.       case 83:
  1135.          return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L, active1, 0L);
  1136.       case 84:
  1137.          if ((active0 & 0x8000000L) != 0L)
  1138.             return jjStartNfaWithStates_1(1, 27, 0);
  1139.          else if ((active1 & 0x100L) != 0L)
  1140.             return jjStartNfaWithStates_1(1, 72, 0);
  1141.          return jjMoveStringLiteralDfa2_1(active0, 0xd000008000000000L, active1, 0L);
  1142.       case 85:
  1143.          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x3L);
  1144.       case 97:
  1145.          return jjMoveStringLiteralDfa2_1(active0, 0x120800000043000L, active1, 0x804L);
  1146.       case 98:
  1147.          return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L, active1, 0L);
  1148.       case 99:
  1149.          return jjMoveStringLiteralDfa2_1(active0, 0x200000000000000L, active1, 0L);
  1150.       case 100:
  1151.          if ((active0 & 0x400000L) != 0L)
  1152.             return jjStartNfaWithStates_1(1, 22, 0);
  1153.          else if ((active1 & 0x8L) != 0L)
  1154.             return jjStartNfaWithStates_1(1, 67, 0);
  1155.          return jjMoveStringLiteralDfa2_1(active0, 0x100L, active1, 0L);
  1156.       case 101:
  1157.          return jjMoveStringLiteralDfa2_1(active0, 0x403002000080000L, active1, 0x10L);
  1158.       case 102:
  1159.          return jjMoveStringLiteralDfa2_1(active0, 0x800000L, active1, 0L);
  1160.       case 104:
  1161.          if ((active1 & 0x20L) != 0L)
  1162.             return jjStartNfaWithStates_1(1, 69, 0);
  1163.          break;
  1164.       case 105:
  1165.          if ((active0 & 0x200000000000L) != 0L)
  1166.          {
  1167.             jjmatchedKind = 45;
  1168.             jjmatchedPos = 1;
  1169.          }
  1170.          return jjMoveStringLiteralDfa2_1(active0, 0x400003104000L, active1, 0x40L);
  1171.       case 108:
  1172.          if ((active0 & 0x4000000L) != 0L)
  1173.             return jjStartNfaWithStates_1(1, 26, 0);
  1174.          else if ((active0 & 0x4000000000000L) != 0L)
  1175.             return jjStartNfaWithStates_1(1, 50, 0);
  1176.          else if ((active1 & 0x400L) != 0L)
  1177.             return jjStartNfaWithStates_1(1, 74, 0);
  1178.          return jjMoveStringLiteralDfa2_1(active0, 0x8000L, active1, 0L);
  1179.       case 109:
  1180.          if ((active0 & 0x10000000L) != 0L)
  1181.             return jjStartNfaWithStates_1(1, 28, 0);
  1182.          return jjMoveStringLiteralDfa2_1(active0, 0x800020000000000L, active1, 0L);
  1183.       case 110:
  1184.          return jjMoveStringLiteralDfa2_1(active0, 0x40000000000L, active1, 0L);
  1185.       case 111:
  1186.          return jjMoveStringLiteralDfa2_1(active0, 0x60210000L, active1, 0L);
  1187.       case 112:
  1188.          return jjMoveStringLiteralDfa2_1(active0, 0x8000000000200L, active1, 0L);
  1189.       case 114:
  1190.          if ((active0 & 0x20000L) != 0L)
  1191.             return jjStartNfaWithStates_1(1, 17, 0);
  1192.          else if ((active0 & 0x4000000000L) != 0L)
  1193.             return jjStartNfaWithStates_1(1, 38, 0);
  1194.          else if ((active1 & 0x80L) != 0L)
  1195.             return jjStartNfaWithStates_1(1, 71, 0);
  1196.          return jjMoveStringLiteralDfa2_1(active0, 0xc0000000000400L, active1, 0L);
  1197.       case 115:
  1198.          return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L, active1, 0L);
  1199.       case 116:
  1200.          if ((active0 & 0x8000000L) != 0L)
  1201.             return jjStartNfaWithStates_1(1, 27, 0);
  1202.          else if ((active1 & 0x100L) != 0L)
  1203.             return jjStartNfaWithStates_1(1, 72, 0);
  1204.          return jjMoveStringLiteralDfa2_1(active0, 0xd000008000000000L, active1, 0L);
  1205.       case 117:
  1206.          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x3L);
  1207.       default :
  1208.          break;
  1209.    }
  1210.    return jjStartNfa_1(0, active0, active1);
  1211. }
  1212. private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1)
  1213. {
  1214.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1215.       return jjStartNfa_1(0, old0, old1); 
  1216.    try { curChar = input_stream.readChar(); }
  1217.    catch(java.io.IOException e) {
  1218.       jjStopStringLiteralDfa_1(1, active0, active1);
  1219.       return 2;
  1220.    }
  1221.    switch(curChar)
  1222.    {
  1223.       case 65:
  1224.          return jjMoveStringLiteralDfa3_1(active0, 0x800002000000000L, active1, 0L);
  1225.       case 66:
  1226.          if ((active1 & 0x1L) != 0L)
  1227.             return jjStartNfaWithStates_1(2, 64, 0);
  1228.          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x4L);
  1229.       case 68:
  1230.          if ((active0 & 0x100000000000L) != 0L)
  1231.             return jjStartNfaWithStates_1(2, 44, 0);
  1232.          return jjMoveStringLiteralDfa3_1(active0, 0x210100L, active1, 0L);
  1233.       case 69:
  1234.          if ((active0 & 0x40000000000000L) != 0L)
  1235.             return jjStartNfaWithStates_1(2, 54, 0);
  1236.          return jjMoveStringLiteralDfa3_1(active0, 0x400L, active1, 0L);
  1237.       case 71:
  1238.          if ((active0 & 0x4000L) != 0L)
  1239.             return jjStartNfaWithStates_1(2, 14, 0);
  1240.          else if ((active0 & 0x20000000000L) != 0L)
  1241.             return jjStartNfaWithStates_1(2, 41, 0);
  1242.          break;
  1243.       case 73:
  1244.          return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L, active1, 0L);
  1245.       case 76:
  1246.          return jjMoveStringLiteralDfa3_1(active0, 0x400000000000000L, active1, 0L);
  1247.       case 77:
  1248.          return jjMoveStringLiteralDfa3_1(active0, 0x100008000000000L, active1, 0L);
  1249.       case 78:
  1250.          if ((active0 & 0x800000L) != 0L)
  1251.             return jjStartNfaWithStates_1(2, 23, 0);
  1252.          return jjMoveStringLiteralDfa3_1(active0, 0x1400020080000L, active1, 0L);
  1253.       case 79:
  1254.          return jjMoveStringLiteralDfa3_1(active0, 0x80000000008000L, active1, 0L);
  1255.       case 80:
  1256.          if ((active0 & 0x800000000000L) != 0L)
  1257.             return jjStartNfaWithStates_1(2, 47, 0);
  1258.          else if ((active1 & 0x2L) != 0L)
  1259.             return jjStartNfaWithStates_1(2, 65, 0);
  1260.          return jjMoveStringLiteralDfa3_1(active0, 0x40000040200L, active1, 0L);
  1261.       case 82:
  1262.          if ((active0 & 0x1000000L) != 0L)
  1263.             return jjStartNfaWithStates_1(2, 24, 0);
  1264.          else if ((active1 & 0x800L) != 0L)
  1265.             return jjStartNfaWithStates_1(2, 75, 0);
  1266.          return jjMoveStringLiteralDfa3_1(active0, 0x5220000040000000L, active1, 0L);
  1267.       case 83:
  1268.          return jjMoveStringLiteralDfa3_1(active0, 0x3000L, active1, 0L);
  1269.       case 84:
  1270.          return jjMoveStringLiteralDfa3_1(active0, 0xa000000100000L, active1, 0x40L);
  1271.       case 86:
  1272.          if ((active0 & 0x2000000L) != 0L)
  1273.             return jjStartNfaWithStates_1(2, 25, 0);
  1274.          break;
  1275.       case 88:
  1276.          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x10L);
  1277.       case 89:
  1278.          return jjMoveStringLiteralDfa3_1(active0, 0x8000000000000000L, active1, 0L);
  1279.       case 97:
  1280.          return jjMoveStringLiteralDfa3_1(active0, 0x800002000000000L, active1, 0L);
  1281.       case 98:
  1282.          if ((active1 & 0x1L) != 0L)
  1283.             return jjStartNfaWithStates_1(2, 64, 0);
  1284.          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x4L);
  1285.       case 100:
  1286.          if ((active0 & 0x100000000000L) != 0L)
  1287.             return jjStartNfaWithStates_1(2, 44, 0);
  1288.          return jjMoveStringLiteralDfa3_1(active0, 0x210100L, active1, 0L);
  1289.       case 101:
  1290.          if ((active0 & 0x40000000000000L) != 0L)
  1291.             return jjStartNfaWithStates_1(2, 54, 0);
  1292.          return jjMoveStringLiteralDfa3_1(active0, 0x400L, active1, 0L);
  1293.       case 103:
  1294.          if ((active0 & 0x4000L) != 0L)
  1295.             return jjStartNfaWithStates_1(2, 14, 0);
  1296.          else if ((active0 & 0x20000000000L) != 0L)
  1297.             return jjStartNfaWithStates_1(2, 41, 0);
  1298.          break;
  1299.       case 105:
  1300.          return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L, active1, 0L);
  1301.       case 108:
  1302.          return jjMoveStringLiteralDfa3_1(active0, 0x400000000000000L, active1, 0L);
  1303.       case 109:
  1304.          return jjMoveStringLiteralDfa3_1(active0, 0x100008000000000L, active1, 0L);
  1305.       case 110:
  1306.          if ((active0 & 0x800000L) != 0L)
  1307.             return jjStartNfaWithStates_1(2, 23, 0);
  1308.          return jjMoveStringLiteralDfa3_1(active0, 0x1400020080000L, active1, 0L);
  1309.       case 111:
  1310.          return jjMoveStringLiteralDfa3_1(active0, 0x80000000008000L, active1, 0L);
  1311.       case 112:
  1312.          if ((active0 & 0x800000000000L) != 0L)
  1313.             return jjStartNfaWithStates_1(2, 47, 0);
  1314.          else if ((active1 & 0x2L) != 0L)
  1315.             return jjStartNfaWithStates_1(2, 65, 0);
  1316.          return jjMoveStringLiteralDfa3_1(active0, 0x40000040200L, active1, 0L);
  1317.       case 114:
  1318.          if ((active0 & 0x1000000L) != 0L)
  1319.             return jjStartNfaWithStates_1(2, 24, 0);
  1320.          else if ((active1 & 0x800L) != 0L)
  1321.             return jjStartNfaWithStates_1(2, 75, 0);
  1322.          return jjMoveStringLiteralDfa3_1(active0, 0x5220000040000000L, active1, 0L);
  1323.       case 115:
  1324.          return jjMoveStringLiteralDfa3_1(active0, 0x3000L, active1, 0L);
  1325.       case 116:
  1326.          return jjMoveStringLiteralDfa3_1(active0, 0xa000000100000L, active1, 0x40L);
  1327.       case 118:
  1328.          if ((active0 & 0x2000000L) != 0L)
  1329.             return jjStartNfaWithStates_1(2, 25, 0);
  1330.          break;
  1331.       case 120:
  1332.          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x10L);
  1333.       case 121:
  1334.          return jjMoveStringLiteralDfa3_1(active0, 0x8000000000000000L, active1, 0L);
  1335.       default :
  1336.          break;
  1337.    }
  1338.    return jjStartNfa_1(1, active0, active1);
  1339. }
  1340. private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1)
  1341. {
  1342.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1343.       return jjStartNfa_1(1, old0, old1); 
  1344.    try { curChar = input_stream.readChar(); }
  1345.    catch(java.io.IOException e) {
  1346.       jjStopStringLiteralDfa_1(2, active0, active1);
  1347.       return 3;
  1348.    }
  1349.    switch(curChar)
  1350.    {
  1351.       case 65:
  1352.          if ((active0 & 0x400L) != 0L)
  1353.             return jjStartNfaWithStates_1(3, 10, 0);
  1354.          else if ((active0 & 0x2000000000000L) != 0L)
  1355.             return jjStartNfaWithStates_1(3, 49, 0);
  1356.          return jjMoveStringLiteralDfa4_1(active0, 0x20000000000000L, active1, 0L);
  1357.       case 67:
  1358.          return jjMoveStringLiteralDfa4_1(active0, 0x8000L, active1, 0L);
  1359.       case 68:
  1360.          if ((active0 & 0x2000000000L) != 0L)
  1361.             return jjStartNfaWithStates_1(3, 37, 0);
  1362.          break;
  1363.       case 69:
  1364.          if ((active0 & 0x1000L) != 0L)
  1365.          {
  1366.             jjmatchedKind = 12;
  1367.             jjmatchedPos = 3;
  1368.          }
  1369.          else if ((active0 & 0x100000L) != 0L)
  1370.             return jjStartNfaWithStates_1(3, 20, 0);
  1371.          else if ((active0 & 0x200000L) != 0L)
  1372.             return jjStartNfaWithStates_1(3, 21, 0);
  1373.          return jjMoveStringLiteralDfa4_1(active0, 0x400000000002000L, active1, 0L);
  1374.       case 73:
  1375.          return jjMoveStringLiteralDfa4_1(active0, 0x1208000000000000L, active1, 0L);
  1376.       case 75:
  1377.          if ((active0 & 0x400000000000L) != 0L)
  1378.             return jjStartNfaWithStates_1(3, 46, 0);
  1379.          break;
  1380.       case 76:
  1381.          if ((active0 & 0x8000000000L) != 0L)
  1382.             return jjStartNfaWithStates_1(3, 39, 0);
  1383.          return jjMoveStringLiteralDfa4_1(active0, 0x8800000000000200L, active1, 0x44L);
  1384.       case 77:
  1385.          if ((active0 & 0x40000000L) != 0L)
  1386.             return jjStartNfaWithStates_1(3, 30, 0);
  1387.          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000000L, active1, 0L);
  1388.       case 78:
  1389.          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000L, active1, 0L);
  1390.       case 79:
  1391.          return jjMoveStringLiteralDfa4_1(active0, 0x4000000000000000L, active1, 0L);
  1392.       case 80:
  1393.          if ((active0 & 0x100000000000000L) != 0L)
  1394.             return jjStartNfaWithStates_1(3, 56, 0);
  1395.          break;
  1396.       case 82:
  1397.          return jjMoveStringLiteralDfa4_1(active0, 0x100L, active1, 0L);
  1398.       case 84:
  1399.          if ((active0 & 0x20000000L) != 0L)
  1400.             return jjStartNfaWithStates_1(3, 29, 0);
  1401.          return jjMoveStringLiteralDfa4_1(active0, 0xc0000L, active1, 0x10L);
  1402.       case 85:
  1403.          if ((active0 & 0x1000000000000L) != 0L)
  1404.             return jjStartNfaWithStates_1(3, 48, 0);
  1405.          return jjMoveStringLiteralDfa4_1(active0, 0x40000000000L, active1, 0L);
  1406.       case 89:
  1407.          if ((active0 & 0x10000L) != 0L)
  1408.             return jjStartNfaWithStates_1(3, 16, 0);
  1409.          break;
  1410.       case 97:
  1411.          if ((active0 & 0x400L) != 0L)
  1412.             return jjStartNfaWithStates_1(3, 10, 0);
  1413.          else if ((active0 & 0x2000000000000L) != 0L)
  1414.             return jjStartNfaWithStates_1(3, 49, 0);
  1415.          return jjMoveStringLiteralDfa4_1(active0, 0x20000000000000L, active1, 0L);
  1416.       case 99:
  1417.          return jjMoveStringLiteralDfa4_1(active0, 0x8000L, active1, 0L);
  1418.       case 100:
  1419.          if ((active0 & 0x2000000000L) != 0L)
  1420.             return jjStartNfaWithStates_1(3, 37, 0);
  1421.          break;
  1422.       case 101:
  1423.          if ((active0 & 0x1000L) != 0L)
  1424.          {
  1425.             jjmatchedKind = 12;
  1426.             jjmatchedPos = 3;
  1427.          }
  1428.          else if ((active0 & 0x100000L) != 0L)
  1429.             return jjStartNfaWithStates_1(3, 20, 0);
  1430.          else if ((active0 & 0x200000L) != 0L)
  1431.             return jjStartNfaWithStates_1(3, 21, 0);
  1432.          return jjMoveStringLiteralDfa4_1(active0, 0x400000000002000L, active1, 0L);
  1433.       case 105:
  1434.          return jjMoveStringLiteralDfa4_1(active0, 0x1208000000000000L, active1, 0L);
  1435.       case 107:
  1436.          if ((active0 & 0x400000000000L) != 0L)
  1437.             return jjStartNfaWithStates_1(3, 46, 0);
  1438.          break;
  1439.       case 108:
  1440.          if ((active0 & 0x8000000000L) != 0L)
  1441.             return jjStartNfaWithStates_1(3, 39, 0);
  1442.          return jjMoveStringLiteralDfa4_1(active0, 0x8800000000000200L, active1, 0x44L);
  1443.       case 109:
  1444.          if ((active0 & 0x40000000L) != 0L)
  1445.             return jjStartNfaWithStates_1(3, 30, 0);
  1446.          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000000L, active1, 0L);
  1447.       case 110:
  1448.          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000L, active1, 0L);
  1449.       case 111:
  1450.          return jjMoveStringLiteralDfa4_1(active0, 0x4000000000000000L, active1, 0L);
  1451.       case 112:
  1452.          if ((active0 & 0x100000000000000L) != 0L)
  1453.             return jjStartNfaWithStates_1(3, 56, 0);
  1454.          break;
  1455.       case 114:
  1456.          return jjMoveStringLiteralDfa4_1(active0, 0x100L, active1, 0L);
  1457.       case 116:
  1458.          if ((active0 & 0x20000000L) != 0L)
  1459.             return jjStartNfaWithStates_1(3, 29, 0);
  1460.          return jjMoveStringLiteralDfa4_1(active0, 0xc0000L, active1, 0x10L);
  1461.       case 117:
  1462.          if ((active0 & 0x1000000000000L) != 0L)
  1463.             return jjStartNfaWithStates_1(3, 48, 0);
  1464.          return jjMoveStringLiteralDfa4_1(active0, 0x40000000000L, active1, 0L);
  1465.       case 121:
  1466.          if ((active0 & 0x10000L) != 0L)
  1467.             return jjStartNfaWithStates_1(3, 16, 0);
  1468.          break;
  1469.       default :
  1470.          break;
  1471.    }
  1472.    return jjStartNfa_1(2, active0, active1);
  1473. }
  1474. private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1)
  1475. {
  1476.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1477.       return jjStartNfa_1(2, old0, old1); 
  1478.    try { curChar = input_stream.readChar(); }
  1479.    catch(java.io.IOException e) {
  1480.       jjStopStringLiteralDfa_1(3, active0, active1);
  1481.       return 4;
  1482.    }
  1483.    switch(curChar)
  1484.    {
  1485.       case 65:
  1486.          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x10L);
  1487.       case 67:
  1488.          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000000L, active1, 0L);
  1489.       case 68:
  1490.          return jjMoveStringLiteralDfa5_1(active0, 0x80000000000L, active1, 0L);
  1491.       case 69:
  1492.          if ((active0 & 0x8000000000000000L) != 0L)
  1493.             return jjStartNfaWithStates_1(4, 63, 0);
  1494.          else if ((active1 & 0x4L) != 0L)
  1495.             return jjStartNfaWithStates_1(4, 66, 0);
  1496.          else if ((active1 & 0x40L) != 0L)
  1497.             return jjStartNfaWithStates_1(4, 70, 0);
  1498.          return jjMoveStringLiteralDfa5_1(active0, 0x80300L, active1, 0L);
  1499.       case 70:
  1500.          return jjMoveStringLiteralDfa5_1(active0, 0x2000L, active1, 0L);
  1501.       case 73:
  1502.          return jjMoveStringLiteralDfa5_1(active0, 0x40000L, active1, 0L);
  1503.       case 75:
  1504.          return jjMoveStringLiteralDfa5_1(active0, 0x1000000000008000L, active1, 0L);
  1505.       case 76:
  1506.          if ((active0 & 0x800000000000000L) != 0L)
  1507.             return jjStartNfaWithStates_1(4, 59, 0);
  1508.          break;
  1509.       case 77:
  1510.          if ((active0 & 0x20000000000000L) != 0L)
  1511.             return jjStartNfaWithStates_1(4, 53, 0);
  1512.          break;
  1513.       case 78:
  1514.          return jjMoveStringLiteralDfa5_1(active0, 0x4000000000000000L, active1, 0L);
  1515.       case 79:
  1516.          return jjMoveStringLiteralDfa5_1(active0, 0x8000000000000L, active1, 0L);
  1517.       case 80:
  1518.          return jjMoveStringLiteralDfa5_1(active0, 0x280000000000000L, active1, 0L);
  1519.       case 84:
  1520.          if ((active0 & 0x40000000000L) != 0L)
  1521.             return jjStartNfaWithStates_1(4, 42, 0);
  1522.          break;
  1523.       case 97:
  1524.          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x10L);
  1525.       case 99:
  1526.          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000000L, active1, 0L);
  1527.       case 100:
  1528.          return jjMoveStringLiteralDfa5_1(active0, 0x80000000000L, active1, 0L);
  1529.       case 101:
  1530.          if ((active0 & 0x8000000000000000L) != 0L)
  1531.             return jjStartNfaWithStates_1(4, 63, 0);
  1532.          else if ((active1 & 0x4L) != 0L)
  1533.             return jjStartNfaWithStates_1(4, 66, 0);
  1534.          else if ((active1 & 0x40L) != 0L)
  1535.             return jjStartNfaWithStates_1(4, 70, 0);
  1536.          return jjMoveStringLiteralDfa5_1(active0, 0x80300L, active1, 0L);
  1537.       case 102:
  1538.          return jjMoveStringLiteralDfa5_1(active0, 0x2000L, active1, 0L);
  1539.       case 105:
  1540.          return jjMoveStringLiteralDfa5_1(active0, 0x40000L, active1, 0L);
  1541.       case 107:
  1542.          return jjMoveStringLiteralDfa5_1(active0, 0x1000000000008000L, active1, 0L);
  1543.       case 108:
  1544.          if ((active0 & 0x800000000000000L) != 0L)
  1545.             return jjStartNfaWithStates_1(4, 59, 0);
  1546.          break;
  1547.       case 109:
  1548.          if ((active0 & 0x20000000000000L) != 0L)
  1549.             return jjStartNfaWithStates_1(4, 53, 0);
  1550.          break;
  1551.       case 110:
  1552.          return jjMoveStringLiteralDfa5_1(active0, 0x4000000000000000L, active1, 0L);
  1553.       case 111:
  1554.          return jjMoveStringLiteralDfa5_1(active0, 0x8000000000000L, active1, 0L);
  1555.       case 112:
  1556.          return jjMoveStringLiteralDfa5_1(active0, 0x280000000000000L, active1, 0L);
  1557.       case 116:
  1558.          if ((active0 & 0x40000000000L) != 0L)
  1559.             return jjStartNfaWithStates_1(4, 42, 0);
  1560.          break;
  1561.       default :
  1562.          break;
  1563.    }
  1564.    return jjStartNfa_1(3, active0, active1);
  1565. }
  1566. private final int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1)
  1567. {
  1568.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1569.       return jjStartNfa_1(3, old0, old1); 
  1570.    try { curChar = input_stream.readChar(); }
  1571.    catch(java.io.IOException e) {
  1572.       jjStopStringLiteralDfa_1(4, active0, active1);
  1573.       return 5;
  1574.    }
  1575.    switch(curChar)
  1576.    {
  1577.       case 69:
  1578.          if ((active0 & 0x1000000000000000L) != 0L)
  1579.             return jjStartNfaWithStates_1(5, 60, 0);
  1580.          return jjMoveStringLiteralDfa6_1(active0, 0x80000000000L, active1, 0L);
  1581.       case 71:
  1582.          if ((active0 & 0x4000000000000000L) != 0L)
  1583.             return jjStartNfaWithStates_1(5, 62, 0);
  1584.          break;
  1585.       case 78:
  1586.          if ((active0 & 0x8000000000000L) != 0L)
  1587.             return jjStartNfaWithStates_1(5, 51, 0);
  1588.          break;
  1589.       case 79:
  1590.          return jjMoveStringLiteralDfa6_1(active0, 0x42000L, active1, 0L);
  1591.       case 81:
  1592.          return jjMoveStringLiteralDfa6_1(active0, 0x8000L, active1, 0L);
  1593.       case 82:
  1594.          if ((active0 & 0x80000L) != 0L)
  1595.             return jjStartNfaWithStates_1(5, 19, 0);
  1596.          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x10L);
  1597.       case 83:
  1598.          return jjMoveStringLiteralDfa6_1(active0, 0x100L, active1, 0L);
  1599.       case 84:
  1600.          if ((active0 & 0x200L) != 0L)
  1601.             return jjStartNfaWithStates_1(5, 9, 0);
  1602.          else if ((active0 & 0x80000000000000L) != 0L)
  1603.             return jjStartNfaWithStates_1(5, 55, 0);
  1604.          else if ((active0 & 0x200000000000000L) != 0L)
  1605.             return jjStartNfaWithStates_1(5, 57, 0);
  1606.          else if ((active0 & 0x400000000000000L) != 0L)
  1607.             return jjStartNfaWithStates_1(5, 58, 0);
  1608.          break;
  1609.       case 101:
  1610.          if ((active0 & 0x1000000000000000L) != 0L)
  1611.             return jjStartNfaWithStates_1(5, 60, 0);
  1612.          return jjMoveStringLiteralDfa6_1(active0, 0x80000000000L, active1, 0L);
  1613.       case 103:
  1614.          if ((active0 & 0x4000000000000000L) != 0L)
  1615.             return jjStartNfaWithStates_1(5, 62, 0);
  1616.          break;
  1617.       case 110:
  1618.          if ((active0 & 0x8000000000000L) != 0L)
  1619.             return jjStartNfaWithStates_1(5, 51, 0);
  1620.          break;
  1621.       case 111:
  1622.          return jjMoveStringLiteralDfa6_1(active0, 0x42000L, active1, 0L);
  1623.       case 113:
  1624.          return jjMoveStringLiteralDfa6_1(active0, 0x8000L, active1, 0L);
  1625.       case 114:
  1626.          if ((active0 & 0x80000L) != 0L)
  1627.             return jjStartNfaWithStates_1(5, 19, 0);
  1628.          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x10L);
  1629.       case 115:
  1630.          return jjMoveStringLiteralDfa6_1(active0, 0x100L, active1, 0L);
  1631.       case 116:
  1632.          if ((active0 & 0x200L) != 0L)
  1633.             return jjStartNfaWithStates_1(5, 9, 0);
  1634.          else if ((active0 & 0x80000000000000L) != 0L)
  1635.             return jjStartNfaWithStates_1(5, 55, 0);
  1636.          else if ((active0 & 0x200000000000000L) != 0L)
  1637.             return jjStartNfaWithStates_1(5, 57, 0);
  1638.          else if ((active0 & 0x400000000000000L) != 0L)
  1639.             return jjStartNfaWithStates_1(5, 58, 0);
  1640.          break;
  1641.       default :
  1642.          break;
  1643.    }
  1644.    return jjStartNfa_1(4, active0, active1);
  1645. }
  1646. private final int jjMoveStringLiteralDfa6_1(long old0, long active0, long old1, long active1)
  1647. {
  1648.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1649.       return jjStartNfa_1(4, old0, old1); 
  1650.    try { curChar = input_stream.readChar(); }
  1651.    catch(java.io.IOException e) {
  1652.       jjStopStringLiteralDfa_1(5, active0, active1);
  1653.       return 6;
  1654.    }
  1655.    switch(curChar)
  1656.    {
  1657.       case 69:
  1658.          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x10L);
  1659.       case 78:
  1660.          if ((active0 & 0x40000L) != 0L)
  1661.             return jjStartNfaWithStates_1(6, 18, 0);
  1662.          return jjMoveStringLiteralDfa7_1(active0, 0x2000L, active1, 0L);
  1663.       case 83:
  1664.          if ((active0 & 0x100L) != 0L)
  1665.             return jjStartNfaWithStates_1(6, 8, 0);
  1666.          break;
  1667.       case 85:
  1668.          return jjMoveStringLiteralDfa7_1(active0, 0x8000L, active1, 0L);
  1669.       case 88:
  1670.          if ((active0 & 0x80000000000L) != 0L)
  1671.             return jjStartNfaWithStates_1(6, 43, 0);
  1672.          break;
  1673.       case 101:
  1674.          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x10L);
  1675.       case 110:
  1676.          if ((active0 & 0x40000L) != 0L)
  1677.             return jjStartNfaWithStates_1(6, 18, 0);
  1678.          return jjMoveStringLiteralDfa7_1(active0, 0x2000L, active1, 0L);
  1679.       case 115:
  1680.          if ((active0 & 0x100L) != 0L)
  1681.             return jjStartNfaWithStates_1(6, 8, 0);
  1682.          break;
  1683.       case 117:
  1684.          return jjMoveStringLiteralDfa7_1(active0, 0x8000L, active1, 0L);
  1685.       case 120:
  1686.          if ((active0 & 0x80000000000L) != 0L)
  1687.             return jjStartNfaWithStates_1(6, 43, 0);
  1688.          break;
  1689.       default :
  1690.          break;
  1691.    }
  1692.    return jjStartNfa_1(5, active0, active1);
  1693. }
  1694. private final int jjMoveStringLiteralDfa7_1(long old0, long active0, long old1, long active1)
  1695. {
  1696.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1697.       return jjStartNfa_1(5, old0, old1); 
  1698.    try { curChar = input_stream.readChar(); }
  1699.    catch(java.io.IOException e) {
  1700.       jjStopStringLiteralDfa_1(6, active0, active1);
  1701.       return 7;
  1702.    }
  1703.    switch(curChar)
  1704.    {
  1705.       case 65:
  1706.          if ((active1 & 0x10L) != 0L)
  1707.             return jjStartNfaWithStates_1(7, 68, 0);
  1708.          break;
  1709.       case 79:
  1710.          return jjMoveStringLiteralDfa8_1(active0, 0x8000L, active1, 0L);
  1711.       case 84:
  1712.          if ((active0 & 0x2000L) != 0L)
  1713.             return jjStartNfaWithStates_1(7, 13, 0);
  1714.          break;
  1715.       case 97:
  1716.          if ((active1 & 0x10L) != 0L)
  1717.             return jjStartNfaWithStates_1(7, 68, 0);
  1718.          break;
  1719.       case 111:
  1720.          return jjMoveStringLiteralDfa8_1(active0, 0x8000L, active1, 0L);
  1721.       case 116:
  1722.          if ((active0 & 0x2000L) != 0L)
  1723.             return jjStartNfaWithStates_1(7, 13, 0);
  1724.          break;
  1725.       default :
  1726.          break;
  1727.    }
  1728.    return jjStartNfa_1(6, active0, active1);
  1729. }
  1730. private final int jjMoveStringLiteralDfa8_1(long old0, long active0, long old1, long active1)
  1731. {
  1732.    if (((active0 &= old0) | (active1 &= old1)) == 0L)
  1733.       return jjStartNfa_1(6, old0, old1); 
  1734.    try { curChar = input_stream.readChar(); }
  1735.    catch(java.io.IOException e) {
  1736.       jjStopStringLiteralDfa_1(7, active0, 0L);
  1737.       return 8;
  1738.    }
  1739.    switch(curChar)
  1740.    {
  1741.       case 84:
  1742.          return jjMoveStringLiteralDfa9_1(active0, 0x8000L);
  1743.       case 116:
  1744.          return jjMoveStringLiteralDfa9_1(active0, 0x8000L);
  1745.       default :
  1746.          break;
  1747.    }
  1748.    return jjStartNfa_1(7, active0, 0L);
  1749. }
  1750. private final int jjMoveStringLiteralDfa9_1(long old0, long active0)
  1751. {
  1752.    if (((active0 &= old0)) == 0L)
  1753.       return jjStartNfa_1(7, old0, 0L);
  1754.    try { curChar = input_stream.readChar(); }
  1755.    catch(java.io.IOException e) {
  1756.       jjStopStringLiteralDfa_1(8, active0, 0L);
  1757.       return 9;
  1758.    }
  1759.    switch(curChar)
  1760.    {
  1761.       case 69:
  1762.          if ((active0 & 0x8000L) != 0L)
  1763.             return jjStartNfaWithStates_1(9, 15, 0);
  1764.          break;
  1765.       case 101:
  1766.          if ((active0 & 0x8000L) != 0L)
  1767.             return jjStartNfaWithStates_1(9, 15, 0);
  1768.          break;
  1769.       default :
  1770.          break;
  1771.    }
  1772.    return jjStartNfa_1(8, active0, 0L);
  1773. }
  1774. private final int jjMoveNfa_1(int startState, int curPos)
  1775. {
  1776.    int[] nextStates;
  1777.    int startsAt = 0;
  1778.    jjnewStateCnt = 1;
  1779.    int i = 1;
  1780.    jjstateSet[0] = startState;
  1781.    int j, kind = 0x7fffffff;
  1782.    for (;;)
  1783.    {
  1784.       if (++jjround == 0x7fffffff)
  1785.          ReInitRounds();
  1786.       if (curChar < 64)
  1787.       {
  1788.          long l = 1L << curChar;
  1789.          MatchLoop: do
  1790.          {
  1791.             switch(jjstateSet[--i])
  1792.             {
  1793.                case 0:
  1794.                   if ((0x3ff000000000000L & l) == 0L)
  1795.                      break;
  1796.                   kind = 76;
  1797.                   jjstateSet[jjnewStateCnt++] = 0;
  1798.                   break;
  1799.                default : break;
  1800.             }
  1801.          } while(i != startsAt);
  1802.       }
  1803.       else if (curChar < 128)
  1804.       {
  1805.          long l = 1L << (curChar & 077);
  1806.          MatchLoop: do
  1807.          {
  1808.             switch(jjstateSet[--i])
  1809.             {
  1810.                case 0:
  1811.                   if ((0x7fffffe07fffffeL & l) == 0L)
  1812.                      break;
  1813.                   kind = 76;
  1814.                   jjstateSet[jjnewStateCnt++] = 0;
  1815.                   break;
  1816.                default : break;
  1817.             }
  1818.          } while(i != startsAt);
  1819.       }
  1820.       else
  1821.       {
  1822.          int i2 = (curChar & 0xff) >> 6;
  1823.          long l2 = 1L << (curChar & 077);
  1824.          MatchLoop: do
  1825.          {
  1826.             switch(jjstateSet[--i])
  1827.             {
  1828.                default : break;
  1829.             }
  1830.          } while(i != startsAt);
  1831.       }
  1832.       if (kind != 0x7fffffff)
  1833.       {
  1834.          jjmatchedKind = kind;
  1835.          jjmatchedPos = curPos;
  1836.          kind = 0x7fffffff;
  1837.       }
  1838.       ++curPos;
  1839.       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
  1840.          return curPos;
  1841.       try { curChar = input_stream.readChar(); }
  1842.       catch(java.io.IOException e) { return curPos; }
  1843.    }
  1844. }
  1845. static final int[] jjnextStates = {
  1846.    3, 6, 
  1847. };
  1848. public static final String[] jjstrLiteralImages = {
  1849. "", null, null, null, null, "\74\57", null, null, null, null, null, null, null, 
  1850. null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
  1851. null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
  1852. null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
  1853. null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
  1854. null, null, null, null, null, null, null, null, null, null, null, "\76", "\75", null, 
  1855. null, null, null, "\74\57", "\74", null, null, null, null, null, };
  1856. public static final String[] lexStateNames = {
  1857.    "DEFAULT", 
  1858.    "TAG", 
  1859.    "ATTLIST", 
  1860.    "ATTRVAL", 
  1861.    "ATTCOMM", 
  1862. };
  1863. public static final int[] jjnewLexState = {
  1864.    -1, -1, -1, -1, 1, 1, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
  1865.    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
  1866.    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
  1867.    2, 2, -1, -1, 4, 0, 3, -1, -1, -1, -1, 1, 1, -1, 2, -1, -1, 2, 
  1868. };
  1869. static final long[] jjtoToken = {
  1870.    0xfffffffffffffff1L, 0x2e31fffL, 
  1871. };
  1872. static final long[] jjtoSkip = {
  1873.    0xeL, 0x1d00e000L, 
  1874. };
  1875. static final long[] jjtoSpecial = {
  1876.    0x8L, 0x0L, 
  1877. };
  1878. private CharStream input_stream;
  1879. private final int[] jjrounds = new int[16];
  1880. private final int[] jjstateSet = new int[32];
  1881. protected char curChar;
  1882. public html32TokenManager(CharStream stream)
  1883. {
  1884.    input_stream = stream;
  1885. }
  1886. public html32TokenManager(CharStream stream, int lexState)
  1887. {
  1888.    this(stream);
  1889.    SwitchTo(lexState);
  1890. }
  1891. public void ReInit(CharStream stream)
  1892. {
  1893.    jjmatchedPos = jjnewStateCnt = 0;
  1894.    curLexState = defaultLexState;
  1895.    input_stream = stream;
  1896.    ReInitRounds();
  1897. }
  1898. private final void ReInitRounds()
  1899. {
  1900.    int i;
  1901.    jjround = 0x80000001;
  1902.    for (i = 16; i-- > 0;)
  1903.       jjrounds[i] = 0x80000000;
  1904. }
  1905. public void ReInit(CharStream stream, int lexState)
  1906. {
  1907.    ReInit(stream);
  1908.    SwitchTo(lexState);
  1909. }
  1910. public void SwitchTo(int lexState)
  1911. {
  1912.    if (lexState >= 5 || lexState < 0)
  1913.       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
  1914.    else
  1915.       curLexState = lexState;
  1916. }
  1917.  
  1918. private final Token jjFillToken()
  1919. {
  1920.    Token t = Token.newToken(jjmatchedKind);
  1921.    String im = jjstrLiteralImages[jjmatchedKind];
  1922.    t.image = (im == null) ? input_stream.GetImage() : im;
  1923.    t.kind = jjmatchedKind;
  1924.    t.beginLine = input_stream.getBeginLine();
  1925.    t.beginColumn = input_stream.getBeginColumn();
  1926.    t.endLine = input_stream.getEndLine();
  1927.    t.endColumn = input_stream.getEndColumn();
  1928.    return t;
  1929. }
  1930.  
  1931. int curLexState = 0;
  1932. int defaultLexState = 0;
  1933. int jjnewStateCnt;
  1934. int jjround;
  1935. int jjmatchedPos;
  1936. int jjmatchedKind;
  1937.  
  1938. public final Token getNextToken() 
  1939. {
  1940.   int kind;
  1941.   Token specialToken = null;
  1942.   Token matchedToken;
  1943.   int curPos = 0;
  1944.  
  1945.   EOFLoop :
  1946.   for (;;)
  1947.   {   
  1948.    try   
  1949.    {     
  1950.       curChar = input_stream.BeginToken();
  1951.    }     
  1952.    catch(java.io.IOException e)
  1953.    {        
  1954.       jjmatchedKind = 0;
  1955.       matchedToken = jjFillToken();
  1956.       matchedToken.specialToken = specialToken;
  1957.       return matchedToken;
  1958.    }
  1959.  
  1960.    switch(curLexState)
  1961.    {
  1962.      case 0:
  1963.        jjmatchedKind = 0x7fffffff;
  1964.        jjmatchedPos = 0;
  1965.        curPos = jjMoveStringLiteralDfa0_0();
  1966.        break;
  1967.      case 1:
  1968.        jjmatchedKind = 0x7fffffff;
  1969.        jjmatchedPos = 0;
  1970.        curPos = jjMoveStringLiteralDfa0_1();
  1971.        break;
  1972.      case 2:
  1973.        jjmatchedKind = 0x7fffffff;
  1974.        jjmatchedPos = 0;
  1975.        curPos = jjMoveStringLiteralDfa0_2();
  1976.        break;
  1977.      case 3:
  1978.        jjmatchedKind = 0x7fffffff;
  1979.        jjmatchedPos = 0;
  1980.        curPos = jjMoveStringLiteralDfa0_3();
  1981.        break;
  1982.      case 4:
  1983.        jjmatchedKind = 0x7fffffff;
  1984.        jjmatchedPos = 0;
  1985.        curPos = jjMoveStringLiteralDfa0_4();
  1986.        break;
  1987.    }
  1988.      if (jjmatchedKind != 0x7fffffff)
  1989.      {
  1990.         if (jjmatchedPos + 1 < curPos)
  1991.            input_stream.backup(curPos - jjmatchedPos - 1);
  1992.         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
  1993.         {
  1994.            matchedToken = jjFillToken();
  1995.            matchedToken.specialToken = specialToken;
  1996.        if (jjnewLexState[jjmatchedKind] != -1)
  1997.          curLexState = jjnewLexState[jjmatchedKind];
  1998.            return matchedToken;
  1999.         }
  2000.         else
  2001.         {
  2002.            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
  2003.            {
  2004.               matchedToken = jjFillToken();
  2005.               if (specialToken == null)
  2006.                  specialToken = matchedToken;
  2007.               else
  2008.               {
  2009.                  matchedToken.specialToken = specialToken;
  2010.                  specialToken = (specialToken.next = matchedToken);
  2011.               }
  2012.            }
  2013.          if (jjnewLexState[jjmatchedKind] != -1)
  2014.            curLexState = jjnewLexState[jjmatchedKind];
  2015.            continue EOFLoop;
  2016.         }
  2017.      }
  2018.      int error_line = input_stream.getEndLine();
  2019.      int error_column = input_stream.getEndColumn();
  2020.      String error_after = null;
  2021.      boolean EOFSeen = false;
  2022.      try { input_stream.readChar(); input_stream.backup(1); }
  2023.      catch (java.io.IOException e1) {
  2024.         EOFSeen = true;
  2025.         error_after = curPos <= 1 ? "" : input_stream.GetImage();
  2026.         if (curChar == '\n' || curChar == '\r') {
  2027.            error_line++;
  2028.            error_column = 0;
  2029.         }
  2030.         else
  2031.            error_column++;
  2032.      }
  2033.      if (!EOFSeen) {
  2034.         input_stream.backup(1);
  2035.         error_after = curPos <= 1 ? "" : input_stream.GetImage();
  2036.      }
  2037.      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  2038.   }
  2039. }
  2040.  
  2041. }
  2042.