Coverage Report

Coverage Report - org.apache.commons.configuration.plist.PropertyListParserTokenManager

Classes in this File

Line Coverage

Branch Coverage

Complexity

PropertyListParserTokenManager

62%

257/410

46%

149/322

9,846

 /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
 package org.apache.commons.configuration.plist;
 import java.util.Date;
 import java.util.List;
 import java.util.ArrayList;
 import org.apache.commons.configuration.HierarchicalConfiguration;
 import org.apache.commons.configuration.HierarchicalConfiguration.Node;
 import org.apache.commons.codec.binary.Hex;
 
 /** Token Manager. */
 public class PropertyListParserTokenManager implements PropertyListParserConstants
 {
 
   /** 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)
    {
       case 0:
          if ((active0 & 0x20000120L) != 0L)
          {
             jjmatchedKind = 27;
             return 8;
          }
          if ((active0 & 0x80000L) != 0L)
             return 8;
          if ((active0 & 0x200000L) != 0L)
             return 14;
          if ((active0 & 0x140000L) != 0L)
             return 6;
          return -1;
       case 1:
          if ((active0 & 0x100000L) != 0L)
          {
             jjmatchedKind = 27;
             jjmatchedPos = 1;
             return 3;
          }
          if ((active0 & 0x120L) != 0L)
             return 8;
          return -1;
       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 34:
          return jjStartNfaWithStates_0(0, 21, 14);
       case 40:
          return jjStopAtPos(0, 11);
       case 41:
          return jjStopAtPos(0, 12);
       case 44:
          return jjStopAtPos(0, 13);
       case 47:
          return jjMoveStringLiteralDfa1_0(0x120L);
       case 59:
          return jjStopAtPos(0, 16);
       case 60:
          jjmatchedKind = 18;
          return jjMoveStringLiteralDfa1_0(0x100000L);
       case 61:
          return jjStopAtPos(0, 17);
       case 62:
          return jjStartNfaWithStates_0(0, 19, 8);
       case 92:
          return jjMoveStringLiteralDfa1_0(0x20000000L);
       case 123:
          return jjStopAtPos(0, 14);
       case 125:
          return jjStopAtPos(0, 15);
       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 34:
          if ((active0 & 0x20000000L) != 0L)
             return jjStopAtPos(1, 29);
          break;
       case 42:
          if ((active0 & 0x20L) != 0L)
             return jjStartNfaWithStates_0(1, 5, 8);
          return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
       case 47:
          if ((active0 & 0x100L) != 0L)
             return jjStartNfaWithStates_0(1, 8, 8);
          break;
       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 68:
          if ((active0 & 0x100000L) != 0L)
             return jjStartNfaWithStates_0(2, 20, 15);
          break;
       default :
          break;
    }
    return jjStartNfa_0(1, active0);
 }
 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 {
    jjmatchedKind = kind;
    jjmatchedPos = pos;
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) { return pos + 1; }
    return jjMoveNfa_0(state, pos + 1);
 }
 static final long[] jjbitVec0 = {
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 };
 private int jjMoveNfa_0(int startState, int curPos)
 {
    int startsAt = 0;
    jjnewStateCnt = 14;
    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 15:
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   if ((0x7ff280100000000L & l) != 0L)
                      jjCheckNAddTwoStates(4, 5);
                   else if (curChar == 62)
                   {
                      if (kind > 26)
                         kind = 26;
                   }
                   break;
                case 6:
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   if ((0x3ff000100002600L & l) != 0L)
                      jjCheckNAddTwoStates(1, 2);
                   else if (curChar == 42)
                      jjstateSet[jjnewStateCnt++] = 3;
                   else if (curChar == 62)
                   {
                      if (kind > 25)
                         kind = 25;
                   }
                   break;
                case 14:
                   if ((0xfffffffbffffffffL & l) != 0L)
                      jjCheckNAddStates(0, 2);
                   else if (curChar == 34)
                   {
                      if (kind > 28)
                         kind = 28;
                   }
                   break;
                case 3:
                case 8:
                   if ((0xd7ffecfaffffd9ffL & l) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                case 0:
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   else if (curChar == 34)
                      jjCheckNAddStates(0, 2);
                   if (curChar == 60)
                      jjstateSet[jjnewStateCnt++] = 6;
                   if (curChar == 60)
                      jjCheckNAddTwoStates(1, 2);
                   break;
                case 1:
                   if ((0x3ff000100002600L & l) != 0L)
                      jjCheckNAddTwoStates(1, 2);
                   break;
                case 2:
                   if (curChar == 62 && kind > 25)
                      kind = 25;
                   break;
                case 4:
                   if ((0x7ff280100000000L & l) != 0L)
                      jjCheckNAddTwoStates(4, 5);
                   break;
                case 5:
                   if (curChar == 62 && kind > 26)
                      kind = 26;
                   break;
                case 7:
                   if (curChar == 60)
                      jjstateSet[jjnewStateCnt++] = 6;
                   break;
                case 9:
                case 11:
                   if (curChar == 34)
                      jjCheckNAddStates(0, 2);
                   break;
                case 10:
                   if ((0xfffffffbffffffffL & l) != 0L)
                      jjCheckNAddStates(0, 2);
                   break;
                case 13:
                   if (curChar == 34 && kind > 28)
                      kind = 28;
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else if (curChar < 128)
       {
          long l = 1L << (curChar & 077);
          do
          {
             switch(jjstateSet[--i])
             {
                case 15:
                   if ((0xd7ffffffffffffffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   if (curChar == 90)
                      jjCheckNAddTwoStates(4, 5);
                   break;
                case 6:
                   if ((0xd7ffffffffffffffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   if ((0x7e0000007eL & l) != 0L)
                      jjCheckNAddTwoStates(1, 2);
                   break;
                case 14:
                   jjCheckNAddStates(0, 2);
                   if (curChar == 92)
                      jjstateSet[jjnewStateCnt++] = 11;
                   break;
                case 3:
                   if ((0xd7ffffffffffffffL & l) != 0L)
                   {
                      if (kind > 27)
                         kind = 27;
                      jjCheckNAdd(8);
                   }
                   if (curChar == 68)
                      jjCheckNAddTwoStates(4, 5);
                   break;
                case 0:
                case 8:
                   if ((0xd7ffffffffffffffL & l) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                case 1:
                   if ((0x7e0000007eL & l) != 0L)
                      jjCheckNAddTwoStates(1, 2);
                   break;
                case 4:
                   if (curChar == 90)
                      jjCheckNAddTwoStates(4, 5);
                   break;
                case 10:
                   jjCheckNAddStates(0, 2);
                   break;
                case 12:
                   if (curChar == 92)
                      jjstateSet[jjnewStateCnt++] = 11;
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else
       {
          int i2 = (curChar & 0xff) >> 6;
          long l2 = 1L << (curChar & 077);
          do
          {
             switch(jjstateSet[--i])
             {
                case 15:
                case 8:
                   if ((jjbitVec0[i2] & l2) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                case 6:
                   if ((jjbitVec0[i2] & l2) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                case 14:
                case 10:
                   if ((jjbitVec0[i2] & l2) != 0L)
                      jjCheckNAddStates(0, 2);
                   break;
                case 3:
                   if ((jjbitVec0[i2] & l2) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                case 0:
                   if ((jjbitVec0[i2] & l2) == 0L)
                      break;
                   if (kind > 27)
                      kind = 27;
                   jjCheckNAdd(8);
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       if (kind != 0x7fffffff)
       {
          jjmatchedKind = kind;
          jjmatchedPos = curPos;
          kind = 0x7fffffff;
       }
       ++curPos;
       if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
          return curPos;
       try { curChar = input_stream.readChar(); }
       catch(java.io.IOException e) { return curPos; }
    }
 }
 private int jjMoveStringLiteralDfa0_2()
 {
    return jjMoveNfa_2(0, 0);
 }
 private int jjMoveNfa_2(int startState, int curPos)
 {
    int startsAt = 0;
    jjnewStateCnt = 3;
    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 ((0x2400L & l) != 0L)
                   {
                      if (kind > 9)
                         kind = 9;
                   }
                   if (curChar == 13)
                      jjstateSet[jjnewStateCnt++] = 1;
                   break;
                case 1:
                   if (curChar == 10 && kind > 9)
                      kind = 9;
                   break;
                case 2:
                   if (curChar == 13)
                      jjstateSet[jjnewStateCnt++] = 1;
                   break;
                default : break;
             }
          } while(i != startsAt);
       }
       else if (curChar < 128)
       {
          long l = 1L << (curChar & 077);
          do
          {
             switch(jjstateSet[--i])
             {
                default : break;
             }
          } while(i != startsAt);
       }
       else
       {
          int i2 = (curChar & 0xff) >> 6;
          long l2 = 1L << (curChar & 077);
          do
          {
             switch(jjstateSet[--i])
             {
                default : break;
             }
          } while(i != startsAt);
       }
       if (kind != 0x7fffffff)
       {
          jjmatchedKind = kind;
          jjmatchedPos = curPos;
          kind = 0x7fffffff;
       }
       ++curPos;
       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
          return curPos;
       try { curChar = input_stream.readChar(); }
       catch(java.io.IOException e) { return curPos; }
    }
 }
 private int jjMoveStringLiteralDfa0_1()
 {
    switch(curChar)
    {
       case 42:
          return jjMoveStringLiteralDfa1_1(0x80L);
       default :
          return 1;
    }
 }
 private int jjMoveStringLiteralDfa1_1(long active0)
 {
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
       return 1;
    }
    switch(curChar)
    {
       case 47:
          if ((active0 & 0x80L) != 0L)
             return jjStopAtPos(1, 7);
          break;
       default :
          return 2;
    }
    return 2;
 }
 static final int[] jjnextStates = {
    10, 12, 13, 
 };
 
 /** Token literal values. */
 public static final String[] jjstrLiteralImages = {
 "", null, null, null, null, null, null, null, null, null, null, "\50", "\51", 
 "\54", "\173", "\175", "\73", "\75", "\74", "\76", "\74\52\104", "\42", null, null, 
 null, null, null, null, null, "\134\42", };
 
 /** Lexer state names. */
 public static final String[] lexStateNames = {
    "DEFAULT",
    "IN_COMMENT",
    "IN_SINGLE_LINE_COMMENT",
 };
 
 /** Lex State array. */
 public static final int[] jjnewLexState = {
    -1, -1, -1, -1, -1, 1, -1, 0, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
    -1, -1, -1, -1, -1, 
 };
 static final long[] jjtoToken = {
    0x3e3ff801L, 
 };
 static final long[] jjtoSkip = {
    0x29eL, 
 };
 static final long[] jjtoSpecial = {
    0x200L, 
 };
 static final long[] jjtoMore = {
    0x560L, 
 };
 protected SimpleCharStream input_stream;
 private final int[] jjrounds = new int[14];
 private final int[] jjstateSet = new int[28];
 private final StringBuilder jjimage = new StringBuilder();
 private StringBuilder image = jjimage;
 private int jjimageLen;
 private int lengthOfMatch;
 protected char curChar;
 /** Constructor. */
 public PropertyListParserTokenManager(SimpleCharStream stream){
    if (SimpleCharStream.staticFlag)
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
    input_stream = stream;
 }
 
 /** Constructor. */
 public PropertyListParserTokenManager(SimpleCharStream stream, int lexState){
    this(stream);
    SwitchTo(lexState);
 }
 
 /** Reinitialise parser. */
 public void ReInit(SimpleCharStream stream)
 {
    jjmatchedPos = jjnewStateCnt = 0;
    curLexState = defaultLexState;
    input_stream = stream;
    ReInitRounds();
 }
 private void ReInitRounds()
 {
    int i;
    jjround = 0x80000001;
    for (i = 14; i-- > 0;)
       jjrounds[i] = 0x80000000;
 }
 
 /** Reinitialise parser. */
 public void ReInit(SimpleCharStream stream, int lexState)
 {
    ReInit(stream);
    SwitchTo(lexState);
 }
 
 /** Switch to specified lex state. */
 public void SwitchTo(int lexState)
 {
    if (lexState >= 3 || 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 specialToken = null;
   Token matchedToken;
   int curPos = 0;
 
   EOFLoop :
   for (;;)
   {
    try
    {
       curChar = input_stream.BeginToken();
    }
    catch(java.io.IOException e)
    {
       jjmatchedKind = 0;
       matchedToken = jjFillToken();
       matchedToken.specialToken = specialToken;
       return matchedToken;
    }
    image = jjimage;
    image.setLength(0);
    jjimageLen = 0;
 
    for (;;)
    {
      switch(curLexState)
      {
        case 0:
          try { input_stream.backup(0);
             while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
                curChar = input_stream.BeginToken();
          }
          catch (java.io.IOException e1) { continue EOFLoop; }
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_0();
          break;
        case 1:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_1();
          if (jjmatchedPos == 0 && jjmatchedKind > 6)
          {
             jjmatchedKind = 6;
          }
          break;
        case 2:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_2();
          if (jjmatchedPos == 0 && jjmatchedKind > 10)
          {
             jjmatchedKind = 10;
          }
          break;
      }
      if (jjmatchedKind != 0x7fffffff)
      {
         if (jjmatchedPos + 1 < curPos)
            input_stream.backup(curPos - jjmatchedPos - 1);
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
         {
            matchedToken = jjFillToken();
            matchedToken.specialToken = specialToken;
        if (jjnewLexState[jjmatchedKind] != -1)
          curLexState = jjnewLexState[jjmatchedKind];
            return matchedToken;
         }
         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
         {
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
            {
               matchedToken = jjFillToken();
               if (specialToken == null)
                  specialToken = matchedToken;
               else
               {
                  matchedToken.specialToken = specialToken;
                  specialToken = (specialToken.next = matchedToken);
               }
               SkipLexicalActions(matchedToken);
            }
            else
               SkipLexicalActions(null);
          if (jjnewLexState[jjmatchedKind] != -1)
            curLexState = jjnewLexState[jjmatchedKind];
            continue EOFLoop;
         }
         jjimageLen += jjmatchedPos + 1;
       if (jjnewLexState[jjmatchedKind] != -1)
         curLexState = jjnewLexState[jjmatchedKind];
         curPos = 0;
         jjmatchedKind = 0x7fffffff;
         try {
            curChar = input_stream.readChar();
            continue;
         }
         catch (java.io.IOException e1) { }
      }
      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);
    }
   }
 }
 
 void SkipLexicalActions(Token matchedToken)
 {
    switch(jjmatchedKind)
    {
       default :
          break;
    }
 }
 private void jjCheckNAdd(int state)
 {
    if (jjrounds[state] != jjround)
    {
       jjstateSet[jjnewStateCnt++] = state;
       jjrounds[state] = jjround;
    }
 }
 private void jjAddStates(int start, int end)
 {
    do {
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    } while (start++ != end);
 }
 private void jjCheckNAddTwoStates(int state1, int state2)
 {
    jjCheckNAdd(state1);
    jjCheckNAdd(state2);
 }
 
 private void jjCheckNAddStates(int start, int end)
 {
    do {
       jjCheckNAdd(jjnextStates[start]);
    } while (start++ != end);
 }
 
 }

1		/* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
2		package org.apache.commons.configuration.plist;
3		import java.util.Date;
4		import java.util.List;
5		import java.util.ArrayList;
6		import org.apache.commons.configuration.HierarchicalConfiguration;
7		import org.apache.commons.configuration.HierarchicalConfiguration.Node;
8		import org.apache.commons.codec.binary.Hex;
9
10		/** Token Manager. */
11		public class PropertyListParserTokenManager implements PropertyListParserConstants
12		{
13
14		/** Debug output. */
15	32	public java.io.PrintStream debugStream = System.out;
16		/** Set debug output. */
17	0	public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
18		private final int jjStopStringLiteralDfa_0(int pos, long active0)
19		{
20	52	switch (pos)
21		{
22		case 0:
23	52	if ((active0 & 0x20000120L) != 0L)
24		{
25	0	jjmatchedKind = 27;
26	0	return 8;
27		}
28	52	if ((active0 & 0x80000L) != 0L)
29	0	return 8;
30	52	if ((active0 & 0x200000L) != 0L)
31	0	return 14;
32	52	if ((active0 & 0x140000L) != 0L)
33	52	return 6;
34	0	return -1;
35		case 1:
36	0	if ((active0 & 0x100000L) != 0L)
37		{
38	0	jjmatchedKind = 27;
39	0	jjmatchedPos = 1;
40	0	return 3;
41		}
42	0	if ((active0 & 0x120L) != 0L)
43	0	return 8;
44	0	return -1;
45		default :
46	0	return -1;
47		}
48		}
49		private final int jjStartNfa_0(int pos, long active0)
50		{
51	52	return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
52		}
53		private int jjStopAtPos(int pos, int kind)
54		{
55	1762	jjmatchedKind = kind;
56	1762	jjmatchedPos = pos;
57	1762	return pos + 1;
58		}
59		private int jjMoveStringLiteralDfa0_0()
60		{
61	2789	switch(curChar)
62		{
63		case 34:
64	211	return jjStartNfaWithStates_0(0, 21, 14);
65		case 40:
66	150	return jjStopAtPos(0, 11);
67		case 41:
68	150	return jjStopAtPos(0, 12);
69		case 44:
70	150	return jjStopAtPos(0, 13);
71		case 47:
72	46	return jjMoveStringLiteralDfa1_0(0x120L);
73		case 59:
74	358	return jjStopAtPos(0, 16);
75		case 60:
76	77	jjmatchedKind = 18;
77	77	return jjMoveStringLiteralDfa1_0(0x100000L);
78		case 61:
79	527	return jjStopAtPos(0, 17);
80		case 62:
81	0	return jjStartNfaWithStates_0(0, 19, 8);
82		case 92:
83	0	return jjMoveStringLiteralDfa1_0(0x20000000L);
84		case 123:
85	202	return jjStopAtPos(0, 14);
86		case 125:
87	202	return jjStopAtPos(0, 15);
88		default :
89	716	return jjMoveNfa_0(0, 0);
90		}
91		}
92		private int jjMoveStringLiteralDfa1_0(long active0)
93		{
94	123	try { curChar = input_stream.readChar(); }
95	0	catch(java.io.IOException e) {
96	0	jjStopStringLiteralDfa_0(0, active0);
97	0	return 1;
98	123	}
99	123	switch(curChar)
100		{
101		case 34:
102	0	if ((active0 & 0x20000000L) != 0L)
103	0	return jjStopAtPos(1, 29);
104		break;
105		case 42:
106	48	if ((active0 & 0x20L) != 0L)
107	23	return jjStartNfaWithStates_0(1, 5, 8);
108	25	return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
109		case 47:
110	23	if ((active0 & 0x100L) != 0L)
111	23	return jjStartNfaWithStates_0(1, 8, 8);
112		break;
113		default :
114		break;
115		}
116	52	return jjStartNfa_0(0, active0);
117		}
118		private int jjMoveStringLiteralDfa2_0(long old0, long active0)
119		{
120	25	if (((active0 &= old0)) == 0L)
121	0	return jjStartNfa_0(0, old0);
122	25	try { curChar = input_stream.readChar(); }
123	0	catch(java.io.IOException e) {
124	0	jjStopStringLiteralDfa_0(1, active0);
125	0	return 2;
126	25	}
127	25	switch(curChar)
128		{
129		case 68:
130	25	if ((active0 & 0x100000L) != 0L)
131	25	return jjStartNfaWithStates_0(2, 20, 15);
132		break;
133		default :
134		break;
135		}
136	0	return jjStartNfa_0(1, active0);
137		}
138		private int jjStartNfaWithStates_0(int pos, int kind, int state)
139		{
140	282	jjmatchedKind = kind;
141	282	jjmatchedPos = pos;
142	282	try { curChar = input_stream.readChar(); }
143	282	catch(java.io.IOException e) { return pos + 1; }
144	282	return jjMoveNfa_0(state, pos + 1);
145		}
146	1	static final long[] jjbitVec0 = {
147		0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
148		};
149		private int jjMoveNfa_0(int startState, int curPos)
150		{
151	1050	int startsAt = 0;
152	1050	jjnewStateCnt = 14;
153	1050	int i = 1;
154	1050	jjstateSet[0] = startState;
155	1050	int kind = 0x7fffffff;
156		for (;;)
157		{
158	9472	if (++jjround == 0x7fffffff)
159	0	ReInitRounds();
160	9472	if (curChar < 64)
161		{
162	2941	long l = 1L << curChar;
163		do
164		{
165	5785	switch(jjstateSet[--i])
166		{
167		case 15:
168	25	if ((0xd7ffecfaffffd9ffL & l) != 0L)
169		{
170	25	if (kind > 27)
171	25	kind = 27;
172	25	jjCheckNAdd(8);
173		}
174	25	if ((0x7ff280100000000L & l) != 0L)
175	25	jjCheckNAddTwoStates(4, 5);
176	0	else if (curChar == 62)
177		{
178	0	if (kind > 26)
179	0	kind = 26;
180		}
181		break;
182		case 6:
183	52	if ((0xd7ffecfaffffd9ffL & l) != 0L)
184		{
185	29	if (kind > 27)
186	29	kind = 27;
187	29	jjCheckNAdd(8);
188		}
189	52	if ((0x3ff000100002600L & l) != 0L)
190	50	jjCheckNAddTwoStates(1, 2);
191	2	else if (curChar == 42)
192	0	jjstateSet[jjnewStateCnt++] = 3;
193	2	else if (curChar == 62)
194		{
195	2	if (kind > 25)
196	2	kind = 25;
197		}
198		break;
199		case 14:
200	0	if ((0xfffffffbffffffffL & l) != 0L)
201	0	jjCheckNAddStates(0, 2);
202	0	else if (curChar == 34)
203		{
204	0	if (kind > 28)
205	0	kind = 28;
206		}
207		break;
208		case 3:
209		case 8:
210	1535	if ((0xd7ffecfaffffd9ffL & l) == 0L)
211	816	break;
212	719	if (kind > 27)
213	719	kind = 27;
214	719	jjCheckNAdd(8);
215	719	break;
216		case 0:
217	0	if ((0xd7ffecfaffffd9ffL & l) != 0L)
218		{
219	0	if (kind > 27)
220	0	kind = 27;
221	0	jjCheckNAdd(8);
222		}
223	0	else if (curChar == 34)
224	0	jjCheckNAddStates(0, 2);
225	0	if (curChar == 60)
226	0	jjstateSet[jjnewStateCnt++] = 6;
227	0	if (curChar == 60)
228	0	jjCheckNAddTwoStates(1, 2);
229		break;
230		case 1:
231	385	if ((0x3ff000100002600L & l) != 0L)
232	335	jjCheckNAddTwoStates(1, 2);
233		break;
234		case 2:
235	385	if (curChar == 62 && kind > 25)
236	50	kind = 25;
237		break;
238		case 4:
239	625	if ((0x7ff280100000000L & l) != 0L)
240	600	jjCheckNAddTwoStates(4, 5);
241		break;
242		case 5:
243	625	if (curChar == 62 && kind > 26)
244	25	kind = 26;
245		break;
246		case 7:
247	0	if (curChar == 60)
248	0	jjstateSet[jjnewStateCnt++] = 6;
249		break;
250		case 9:
251		case 11:
252	50	if (curChar == 34)
253	50	jjCheckNAddStates(0, 2);
254		break;
255		case 10:
256	701	if ((0xfffffffbffffffffL & l) != 0L)
257	440	jjCheckNAddStates(0, 2);
258		break;
259		case 13:
260	701	if (curChar == 34 && kind > 28)
261	261	kind = 28;
262		break;
263		default : break;
264		}
265	5785	} while(i != startsAt);
266	2941	}
267	6531	else if (curChar < 128)
268		{
269	6531	long l = 1L << (curChar & 077);
270		do
271		{
272	9991	switch(jjstateSet[--i])
273		{
274		case 15:
275	0	if ((0xd7ffffffffffffffL & l) != 0L)
276		{
277	0	if (kind > 27)
278	0	kind = 27;
279	0	jjCheckNAdd(8);
280		}
281	0	if (curChar == 90)
282	0	jjCheckNAddTwoStates(4, 5);
283		break;
284		case 6:
285	0	if ((0xd7ffffffffffffffL & l) != 0L)
286		{
287	0	if (kind > 27)
288	0	kind = 27;
289	0	jjCheckNAdd(8);
290		}
291	0	if ((0x7e0000007eL & l) != 0L)
292	0	jjCheckNAddTwoStates(1, 2);
293		break;
294		case 14:
295	211	jjCheckNAddStates(0, 2);
296	211	if (curChar == 92)
297	0	jjstateSet[jjnewStateCnt++] = 11;
298		break;
299		case 3:
300	0	if ((0xd7ffffffffffffffL & l) != 0L)
301		{
302	0	if (kind > 27)
303	0	kind = 27;
304	0	jjCheckNAdd(8);
305		}
306	0	if (curChar == 68)
307	0	jjCheckNAddTwoStates(4, 5);
308		break;
309		case 0:
310		case 8:
311	4640	if ((0xd7ffffffffffffffL & l) == 0L)
312	0	break;
313	4640	if (kind > 27)
314	4640	kind = 27;
315	4640	jjCheckNAdd(8);
316	4640	break;
317		case 1:
318	50	if ((0x7e0000007eL & l) != 0L)
319	50	jjCheckNAddTwoStates(1, 2);
320		break;
321		case 4:
322	0	if (curChar == 90)
323	0	jjCheckNAddTwoStates(4, 5);
324		break;
325		case 10:
326	1680	jjCheckNAddStates(0, 2);
327	1680	break;
328		case 12:
329	1680	if (curChar == 92)
330	50	jjstateSet[jjnewStateCnt++] = 11;
331		break;
332		default : break;
333		}
334	9991	} while(i != startsAt);
335	6531	}
336		else
337		{
338	0	int i2 = (curChar & 0xff) >> 6;
339	0	long l2 = 1L << (curChar & 077);
340		do
341		{
342	0	switch(jjstateSet[--i])
343		{
344		case 15:
345		case 8:
346	0	if ((jjbitVec0[i2] & l2) == 0L)
347	0	break;
348	0	if (kind > 27)
349	0	kind = 27;
350	0	jjCheckNAdd(8);
351	0	break;
352		case 6:
353	0	if ((jjbitVec0[i2] & l2) == 0L)
354	0	break;
355	0	if (kind > 27)
356	0	kind = 27;
357	0	jjCheckNAdd(8);
358	0	break;
359		case 14:
360		case 10:
361	0	if ((jjbitVec0[i2] & l2) != 0L)
362	0	jjCheckNAddStates(0, 2);
363		break;
364		case 3:
365	0	if ((jjbitVec0[i2] & l2) == 0L)
366	0	break;
367	0	if (kind > 27)
368	0	kind = 27;
369	0	jjCheckNAdd(8);
370	0	break;
371		case 0:
372	0	if ((jjbitVec0[i2] & l2) == 0L)
373	0	break;
374	0	if (kind > 27)
375	0	kind = 27;
376	0	jjCheckNAdd(8);
377	0	break;
378		default : break;
379		}
380	0	} while(i != startsAt);
381		}
382	9472	if (kind != 0x7fffffff)
383		{
384	5745	jjmatchedKind = kind;
385	5745	jjmatchedPos = curPos;
386	5745	kind = 0x7fffffff;
387		}
388	9472	++curPos;
389	9472	if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
390	1050	return curPos;
391	8422	try { curChar = input_stream.readChar(); }
392	8422	catch(java.io.IOException e) { return curPos; }
393		}
394		}
395		private int jjMoveStringLiteralDfa0_2()
396		{
397	828	return jjMoveNfa_2(0, 0);
398		}
399		private int jjMoveNfa_2(int startState, int curPos)
400		{
401	828	int startsAt = 0;
402	828	jjnewStateCnt = 3;
403	828	int i = 1;
404	828	jjstateSet[0] = startState;
405	828	int kind = 0x7fffffff;
406		for (;;)
407		{
408	851	if (++jjround == 0x7fffffff)
409	0	ReInitRounds();
410	851	if (curChar < 64)
411		{
412	207	long l = 1L << curChar;
413		do
414		{
415	207	switch(jjstateSet[--i])
416		{
417		case 0:
418	184	if ((0x2400L & l) != 0L)
419		{
420	23	if (kind > 9)
421	23	kind = 9;
422		}
423	184	if (curChar == 13)
424	23	jjstateSet[jjnewStateCnt++] = 1;
425		break;
426		case 1:
427	23	if (curChar == 10 && kind > 9)
428	23	kind = 9;
429		break;
430		case 2:
431	0	if (curChar == 13)
432	0	jjstateSet[jjnewStateCnt++] = 1;
433		break;
434		default : break;
435		}
436	207	} while(i != startsAt);
437	207	}
438	644	else if (curChar < 128)
439		{
440	644	long l = 1L << (curChar & 077);
441		do
442		{
443	644	switch(jjstateSet[--i])
444		{
445		default : break;
446		}
447	644	} while(i != startsAt);
448	644	}
449		else
450		{
451	0	int i2 = (curChar & 0xff) >> 6;
452	0	long l2 = 1L << (curChar & 077);
453		do
454		{
455	0	switch(jjstateSet[--i])
456		{
457		default : break;
458		}
459	0	} while(i != startsAt);
460		}
461	851	if (kind != 0x7fffffff)
462		{
463	46	jjmatchedKind = kind;
464	46	jjmatchedPos = curPos;
465	46	kind = 0x7fffffff;
466		}
467	851	++curPos;
468	851	if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
469	828	return curPos;
470	23	try { curChar = input_stream.readChar(); }
471	23	catch(java.io.IOException e) { return curPos; }
472		}
473		}
474		private int jjMoveStringLiteralDfa0_1()
475		{
476	18699	switch(curChar)
477		{
478		case 42:
479	345	return jjMoveStringLiteralDfa1_1(0x80L);
480		default :
481	18354	return 1;
482		}
483		}
484		private int jjMoveStringLiteralDfa1_1(long active0)
485		{
486	345	try { curChar = input_stream.readChar(); }
487	0	catch(java.io.IOException e) {
488	0	return 1;
489	345	}
490	345	switch(curChar)
491		{
492		case 47:
493	23	if ((active0 & 0x80L) != 0L)
494	23	return jjStopAtPos(1, 7);
495		break;
496		default :
497	322	return 2;
498		}
499	0	return 2;
500		}
501	1	static final int[] jjnextStates = {
502		10, 12, 13,
503		};
504
505		/** Token literal values. */
506	1	public static final String[] jjstrLiteralImages = {
507		"", null, null, null, null, null, null, null, null, null, null, "\50", "\51",
508		"\54", "\173", "\175", "\73", "\75", "\74", "\76", "\74\52\104", "\42", null, null,
509		null, null, null, null, null, "\134\42", };
510
511		/** Lexer state names. */
512	1	public static final String[] lexStateNames = {
513		"DEFAULT",
514		"IN_COMMENT",
515		"IN_SINGLE_LINE_COMMENT",
516		};
517
518		/** Lex State array. */
519	1	public static final int[] jjnewLexState = {
520		-1, -1, -1, -1, -1, 1, -1, 0, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
521		-1, -1, -1, -1, -1,
522		};
523	1	static final long[] jjtoToken = {
524		0x3e3ff801L,
525		};
526	1	static final long[] jjtoSkip = {
527		0x29eL,
528		};
529	1	static final long[] jjtoSpecial = {
530		0x200L,
531		};
532	1	static final long[] jjtoMore = {
533		0x560L,
534		};
535		protected SimpleCharStream input_stream;
536	32	private final int[] jjrounds = new int[14];
537	32	private final int[] jjstateSet = new int[28];
538	32	private final StringBuilder jjimage = new StringBuilder();
539	32	private StringBuilder image = jjimage;
540		private int jjimageLen;
541		private int lengthOfMatch;
542		protected char curChar;
543		/** Constructor. */
544	32	public PropertyListParserTokenManager(SimpleCharStream stream){
545		if (SimpleCharStream.staticFlag)
546		throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
547	32	input_stream = stream;
548	32	}
549
550		/** Constructor. */
551		public PropertyListParserTokenManager(SimpleCharStream stream, int lexState){
552	0	this(stream);
553	0	SwitchTo(lexState);
554	0	}
555
556		/** Reinitialise parser. */
557		public void ReInit(SimpleCharStream stream)
558		{
559	0	jjmatchedPos = jjnewStateCnt = 0;
560	0	curLexState = defaultLexState;
561	0	input_stream = stream;
562	0	ReInitRounds();
563	0	}
564		private void ReInitRounds()
565		{
566		int i;
567	0	jjround = 0x80000001;
568	0	for (i = 14; i-- > 0;)
569	0	jjrounds[i] = 0x80000000;
570	0	}
571
572		/** Reinitialise parser. */
573		public void ReInit(SimpleCharStream stream, int lexState)
574		{
575	0	ReInit(stream);
576	0	SwitchTo(lexState);
577	0	}
578
579		/** Switch to specified lex state. */
580		public void SwitchTo(int lexState)
581		{
582	0	if (lexState >= 3 \|\| lexState < 0)
583	0	throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
584		else
585	0	curLexState = lexState;
586	0	}
587
588		protected Token jjFillToken()
589		{
590		final Token t;
591		final String curTokenImage;
592		final int beginLine;
593		final int endLine;
594		final int beginColumn;
595		final int endColumn;
596	2794	String im = jjstrLiteralImages[jjmatchedKind];
597	2794	curTokenImage = (im == null) ? input_stream.GetImage() : im;
598	2794	beginLine = input_stream.getBeginLine();
599	2794	beginColumn = input_stream.getBeginColumn();
600	2794	endLine = input_stream.getEndLine();
601	2794	endColumn = input_stream.getEndColumn();
602	2794	t = Token.newToken(jjmatchedKind, curTokenImage);
603
604	2794	t.beginLine = beginLine;
605	2794	t.endLine = endLine;
606	2794	t.beginColumn = beginColumn;
607	2794	t.endColumn = endColumn;
608
609	2794	return t;
610		}
611
612	32	int curLexState = 0;
613	32	int defaultLexState = 0;
614		int jjnewStateCnt;
615		int jjround;
616		int jjmatchedPos;
617		int jjmatchedKind;
618
619		/** Get the next Token. */
620		public Token getNextToken()
621		{
622	2771	Token specialToken = null;
623		Token matchedToken;
624	2771	int curPos = 0;
625
626		EOFLoop :
627		for (;;)
628		{
629		try
630		{
631	2840	curChar = input_stream.BeginToken();
632		}
633	28	catch(java.io.IOException e)
634		{
635	28	jjmatchedKind = 0;
636	28	matchedToken = jjFillToken();
637	28	matchedToken.specialToken = specialToken;
638	28	return matchedToken;
639	2812	}
640	2812	image = jjimage;
641	2812	image.setLength(0);
642	2812	jjimageLen = 0;
643
644		for (;;)
645		{
646	22339	switch(curLexState)
647		{
648		case 0:
649	2812	try { input_stream.backup(0);
650	11206	while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
651	8417	curChar = input_stream.BeginToken();
652		}
653	2789	catch (java.io.IOException e1) { continue EOFLoop; }
654	2789	jjmatchedKind = 0x7fffffff;
655	2789	jjmatchedPos = 0;
656	2789	curPos = jjMoveStringLiteralDfa0_0();
657	2789	break;
658		case 1:
659	18699	jjmatchedKind = 0x7fffffff;
660	18699	jjmatchedPos = 0;
661	18699	curPos = jjMoveStringLiteralDfa0_1();
662	18699	if (jjmatchedPos == 0 && jjmatchedKind > 6)
663		{
664	18676	jjmatchedKind = 6;
665		}
666		break;
667		case 2:
668	828	jjmatchedKind = 0x7fffffff;
669	828	jjmatchedPos = 0;
670	828	curPos = jjMoveStringLiteralDfa0_2();
671	828	if (jjmatchedPos == 0 && jjmatchedKind > 10)
672		{
673	805	jjmatchedKind = 10;
674		}
675		break;
676		}
677	22316	if (jjmatchedKind != 0x7fffffff)
678		{
679	22316	if (jjmatchedPos + 1 < curPos)
680	1090	input_stream.backup(curPos - jjmatchedPos - 1);
681	22316	if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
682		{
683	2743	matchedToken = jjFillToken();
684	2743	matchedToken.specialToken = specialToken;
685	2743	if (jjnewLexState[jjmatchedKind] != -1)
686	0	curLexState = jjnewLexState[jjmatchedKind];
687	2743	return matchedToken;
688		}
689	19573	else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
690		{
691	46	if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
692		{
693	23	matchedToken = jjFillToken();
694	23	if (specialToken == null)
695	23	specialToken = matchedToken;
696		else
697		{
698	0	matchedToken.specialToken = specialToken;
699	0	specialToken = (specialToken.next = matchedToken);
700		}
701	23	SkipLexicalActions(matchedToken);
702		}
703		else
704	23	SkipLexicalActions(null);
705	46	if (jjnewLexState[jjmatchedKind] != -1)
706	46	curLexState = jjnewLexState[jjmatchedKind];
707		continue EOFLoop;
708		}
709	19527	jjimageLen += jjmatchedPos + 1;
710	19527	if (jjnewLexState[jjmatchedKind] != -1)
711	46	curLexState = jjnewLexState[jjmatchedKind];
712	19527	curPos = 0;
713	19527	jjmatchedKind = 0x7fffffff;
714		try {
715	19527	curChar = input_stream.readChar();
716	19527	continue;
717		}
718	0	catch (java.io.IOException e1) { }
719		}
720	0	int error_line = input_stream.getEndLine();
721	0	int error_column = input_stream.getEndColumn();
722	0	String error_after = null;
723	0	boolean EOFSeen = false;
724	0	try { input_stream.readChar(); input_stream.backup(1); }
725	0	catch (java.io.IOException e1) {
726	0	EOFSeen = true;
727	0	error_after = curPos <= 1 ? "" : input_stream.GetImage();
728	0	if (curChar == '\n' \|\| curChar == '\r') {
729	0	error_line++;
730	0	error_column = 0;
731		}
732		else
733	0	error_column++;
734	0	}
735	0	if (!EOFSeen) {
736	0	input_stream.backup(1);
737	0	error_after = curPos <= 1 ? "" : input_stream.GetImage();
738		}
739	0	throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
740		}
741		}
742		}
743
744		void SkipLexicalActions(Token matchedToken)
745		{
746	46	switch(jjmatchedKind)
747		{
748		default :
749		break;
750		}
751	46	}
752		private void jjCheckNAdd(int state)
753		{
754	14676	if (jjrounds[state] != jjround)
755		{
756	14676	jjstateSet[jjnewStateCnt++] = state;
757	14676	jjrounds[state] = jjround;
758		}
759	14676	}
760		private void jjAddStates(int start, int end)
761		{
762		do {
763	0	jjstateSet[jjnewStateCnt++] = jjnextStates[start];
764	0	} while (start++ != end);
765	0	}
766		private void jjCheckNAddTwoStates(int state1, int state2)
767		{
768	1060	jjCheckNAdd(state1);
769	1060	jjCheckNAdd(state2);
770	1060	}
771
772		private void jjCheckNAddStates(int start, int end)
773		{
774		do {
775	7143	jjCheckNAdd(jjnextStates[start]);
776	7143	} while (start++ != end);
777	2381	}
778
779		}