/* Generated By:JavaCC: Do not edit this line. JSONParserTokenManager.java */

package com.oracle.jmx.remote.rest.json.parser;

import java.io.StringReader;

import com.oracle.jmx.remote.rest.json.*;

/** Token Manager. */

public class JSONParserTokenManager implements JSONParserConstants

{

  /** Debug output. */

  public  java.io.PrintStream debugStream = System.out;

  /** Set debug output. */

  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }

private final int jjStopStringLiteralDfa_0(int pos, long active0)

{

   switch (pos)

   {

      default :

         return -1;

   }

}

private final int jjStartNfa_0(int pos, long active0)

{

   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);

}

private int jjStopAtPos(int pos, int kind)

{

   jjmatchedKind = kind;

   jjmatchedPos = pos;

   return pos + 1;

}

private int jjMoveStringLiteralDfa0_0()

{

   switch(curChar)

   {

      case 44:

      case 58:

      case 91:

      case 93:

      case 110:

         return jjMoveStringLiteralDfa1_0(0x8000L);

      case 123:

      case 125:

      default :

         return jjMoveNfa_0(0, 0);

   }

}

private int jjMoveStringLiteralDfa1_0(long active0)

{

   try { curChar = input_stream.readChar(); }

   catch(java.io.IOException e) {

      jjStopStringLiteralDfa_0(0, active0);

      return 1;

   }

   switch(curChar)

   {

      case 117:

         return jjMoveStringLiteralDfa2_0(active0, 0x8000L);

      default :

         break;

   }

   return jjStartNfa_0(0, active0);

}

private int jjMoveStringLiteralDfa2_0(long old0, long active0)

{

   if (((active0 &= old0)) == 0L)

      return jjStartNfa_0(0, old0);

   try { curChar = input_stream.readChar(); }

   catch(java.io.IOException e) {

      jjStopStringLiteralDfa_0(1, active0);

      return 2;

   }

   switch(curChar)

   {

      case 108:

         return jjMoveStringLiteralDfa3_0(active0, 0x8000L);

      default :

         break;

   }

   return jjStartNfa_0(1, active0);

}

private int jjMoveStringLiteralDfa3_0(long old0, long active0)

{

   if (((active0 &= old0)) == 0L)

      return jjStartNfa_0(1, old0);

   try { curChar = input_stream.readChar(); }

   catch(java.io.IOException e) {

      jjStopStringLiteralDfa_0(2, active0);

      return 3;

   }

   switch(curChar)

   {

      case 108:

         if ((active0 & 0x8000L) != 0L)

         break;

      default :

         break;

   }

   return jjStartNfa_0(2, active0);

}

static final long[] jjbitVec0 = {

   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL

};

static final long[] jjbitVec2 = {

   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL

};

private int jjMoveNfa_0(int startState, int curPos)

{

   int startsAt = 0;

   int i = 1;

   jjstateSet[0] = startState;

   int kind = 0x7fffffff;

   for (;;)

   {

      if (++jjround == 0x7fffffff)

         ReInitRounds();

      if (curChar < 64)

      {

         long l = 1L << curChar;

         do

         {

            switch(jjstateSet[--i])

            {

               case 0:

                  if ((0x3ff000000000000L & l) != 0L)

                  {

                     if (kind > 7)

                        kind = 7;

                     jjCheckNAddStates(0, 6);

                  }

                  else if (curChar == 45)

                     jjCheckNAddStates(7, 10);

                  else if (curChar == 34)

                     jjCheckNAddStates(11, 13);

                  break;

               case 1:

                  if ((0xfffffffbffffffffL & l) != 0L)

                     jjCheckNAddStates(11, 13);

                  break;

               case 3:

                  if (curChar == 34)

                     jjCheckNAddStates(11, 13);

                  break;

               case 4:

                  if (curChar == 34 && kind > 13)

                     kind = 13;

                  break;

                  if (curChar == 45)

                     jjCheckNAddStates(7, 10);

                  break;

                  if ((0x3ff000000000000L & l) == 0L)

                     break;

                  if (kind > 7)

                     kind = 7;

                  break;

               case 17:

                  if ((0x3ff000000000000L & l) == 0L)

                     break;

                  if (kind > 8)

                     kind = 8;

                  break;

               case 20:

                  break;

                  if ((0x3ff000000000000L & l) == 0L)

                     break;

                  if (kind > 8)

                     kind = 8;

                  break;

               case 24:

                  if ((0x3ff000000000000L & l) != 0L)

                     jjCheckNAddTwoStates(24, 25);

                  break;

                  break;

                  if ((0x3ff000000000000L & l) == 0L)

                     break;

                  if (kind > 8)

                     kind = 8;

                  break;

                  if ((0x3ff000000000000L & l) == 0L)

                     break;

                  if (kind > 7)

                     kind = 7;

                  jjCheckNAddStates(0, 6);

                  break;

               default : break;

            }

         } while(i != startsAt);

      }

      else if (curChar < 128)

      {

         long l = 1L << (curChar & 077);

         do

         {

            switch(jjstateSet[--i])

            {

               case 0:

                     jjstateSet[jjnewStateCnt++] = 11;

                     jjstateSet[jjnewStateCnt++] = 7;

                  break;

               case 1:

                  if ((0xffffffffefffffffL & l) != 0L)

                     jjCheckNAddStates(11, 13);

                  break;

               case 2:

                  if (curChar == 92)

                     jjstateSet[jjnewStateCnt++] = 3;

                  break;

               case 3:

                     jjCheckNAddStates(11, 13);

                  break;

               case 5:

                     kind = 14;

                  break;

               case 6:

                     jjCheckNAdd(5);

                  break;

               case 7:

                     jjstateSet[jjnewStateCnt++] = 6;

                  break;

               case 8:

                     jjstateSet[jjnewStateCnt++] = 7;

                  break;

               case 9:

                     jjCheckNAdd(5);

                  break;

               case 10:

                     jjstateSet[jjnewStateCnt++] = 9;

                  break;

               case 11:

                     jjstateSet[jjnewStateCnt++] = 10;

                  break;

               case 12:

                     jjstateSet[jjnewStateCnt++] = 11;

                  break;

                  if ((0x2000000020L & l) != 0L)

                     jjAddStates(14, 15);

                  break;

                  if ((0x2000000020L & l) != 0L)

                     jjAddStates(16, 17);

                  break;

               default : break;

            }

         } while(i != startsAt);

      }

      else

      {

         int hiByte = (curChar >> 8);

         int i1 = hiByte >> 6;

         long l1 = 1L << (hiByte & 077);

         int i2 = (curChar & 0xff) >> 6;

         long l2 = 1L << (curChar & 077);

         do

         {

            switch(jjstateSet[--i])

            {

               case 1:

                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))

                     jjAddStates(11, 13);

                  break;

               default : break;

            }

         } while(i != startsAt);

      }

      if (kind != 0x7fffffff)

      {

         jjmatchedKind = kind;

         jjmatchedPos = curPos;

         kind = 0x7fffffff;

      }

      ++curPos;

         return curPos;

      try { curChar = input_stream.readChar(); }

      catch(java.io.IOException e) { return curPos; }

   }

}

static final int[] jjnextStates = {

};

private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)

{

   switch(hiByte)

   {

      case 0:

         return ((jjbitVec2[i2] & l2) != 0L);

      default :

         if ((jjbitVec0[i1] & l1) != 0L)

            return true;

         return false;

   }

}

/** Token literal values. */

public static final String[] jjstrLiteralImages = {

"", null, null, null, null, null, null, null, null, null, null, null, null, 

/** Lexer state names. */

public static final String[] lexStateNames = {

   "DEFAULT",

};

static final long[] jjtoToken = {

};

static final long[] jjtoSkip = {

   0x7eL, 

};

protected JavaCharStream input_stream;

protected char curChar;

/** Constructor. */

public JSONParserTokenManager(JavaCharStream stream){

   if (JavaCharStream.staticFlag)

      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");

   input_stream = stream;

}

/** Constructor. */

public JSONParserTokenManager(JavaCharStream stream, int lexState){

   this(stream);

   SwitchTo(lexState);

}

/** Reinitialise parser. */

public void ReInit(JavaCharStream stream)

{

   jjmatchedPos = jjnewStateCnt = 0;

   curLexState = defaultLexState;

   input_stream = stream;

   ReInitRounds();

}

private void ReInitRounds()

{

   int i;

   jjround = 0x80000001;

      jjrounds[i] = 0x80000000;

}

/** Reinitialise parser. */

public void ReInit(JavaCharStream stream, int lexState)

{

   ReInit(stream);

   SwitchTo(lexState);

}

/** Switch to specified lex state. */

public void SwitchTo(int lexState)

{

   if (lexState >= 1 || lexState < 0)

      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);

   else

      curLexState = lexState;

}

protected Token jjFillToken()

{

   final Token t;

   final String curTokenImage;

   final int beginLine;

   final int endLine;

   final int beginColumn;

   final int endColumn;

   String im = jjstrLiteralImages[jjmatchedKind];

   curTokenImage = (im == null) ? input_stream.GetImage() : im;

   beginLine = input_stream.getBeginLine();

   beginColumn = input_stream.getBeginColumn();

   endLine = input_stream.getEndLine();

   endColumn = input_stream.getEndColumn();

   t = Token.newToken(jjmatchedKind, curTokenImage);

   t.beginLine = beginLine;

   t.endLine = endLine;

   t.beginColumn = beginColumn;

   t.endColumn = endColumn;

   return t;

}

int curLexState = 0;

int defaultLexState = 0;

int jjnewStateCnt;

int jjround;

int jjmatchedPos;

int jjmatchedKind;

/** Get the next Token. */

public Token getNextToken() 

{

  Token matchedToken;

  int curPos = 0;

  EOFLoop :

  for (;;)

  {

   try

   {

      curChar = input_stream.BeginToken();

   }

   catch(java.io.IOException e)

   {

      jjmatchedKind = 0;

      matchedToken = jjFillToken();

      return matchedToken;

   }

   try { input_stream.backup(0);

      while (curChar <= 32 && (0x100003700L & (1L << curChar)) != 0L)

         curChar = input_stream.BeginToken();

   }

   catch (java.io.IOException e1) { continue EOFLoop; }

   jjmatchedKind = 0x7fffffff;

   jjmatchedPos = 0;

   curPos = jjMoveStringLiteralDfa0_0();

   if (jjmatchedKind != 0x7fffffff)

   {

      if (jjmatchedPos + 1 < curPos)

         input_stream.backup(curPos - jjmatchedPos - 1);

      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

      {

         matchedToken = jjFillToken();

         return matchedToken;

      }

      else

      {

         continue EOFLoop;

      }

   }

   int error_line = input_stream.getEndLine();

   int error_column = input_stream.getEndColumn();

   String error_after = null;

   boolean EOFSeen = false;

   try { input_stream.readChar(); input_stream.backup(1); }

   catch (java.io.IOException e1) {

      EOFSeen = true;

      error_after = curPos <= 1 ? "" : input_stream.GetImage();

      if (curChar == '\n' || curChar == '\r') {

         error_line++;

         error_column = 0;

      }

      else

         error_column++;

   }

   if (!EOFSeen) {

      input_stream.backup(1);

      error_after = curPos <= 1 ? "" : input_stream.GetImage();

   }

   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);

  }

}

private void jjCheckNAdd(int state)

{

   if (jjrounds[state] != jjround)

   {

      jjstateSet[jjnewStateCnt++] = state;

      jjrounds[state] = jjround;

   }