001 /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */ 002 package org.apache.commons.configuration.plist; 003 import java.util.Date; 004 import java.util.List; 005 import java.util.ArrayList; 006 import org.apache.commons.configuration.HierarchicalConfiguration; 007 import org.apache.commons.configuration.HierarchicalConfiguration.Node; 008 import org.apache.commons.codec.binary.Hex; 009 010 /** Token Manager. */ 011 public class PropertyListParserTokenManager implements PropertyListParserConstants 012 { 013 014 /** Debug output. */ 015 public java.io.PrintStream debugStream = System.out; 016 /** Set debug output. */ 017 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 018 private final int jjStopStringLiteralDfa_0(int pos, long active0) 019 { 020 switch (pos) 021 { 022 case 0: 023 if ((active0 & 0x2000L) != 0L) 024 return 8; 025 if ((active0 & 0x8000L) != 0L) 026 return 14; 027 if ((active0 & 0x800000L) != 0L) 028 { 029 jjmatchedKind = 21; 030 return 8; 031 } 032 if ((active0 & 0x5000L) != 0L) 033 return 6; 034 return -1; 035 case 1: 036 if ((active0 & 0x4000L) != 0L) 037 { 038 jjmatchedKind = 21; 039 jjmatchedPos = 1; 040 return 3; 041 } 042 return -1; 043 default : 044 return -1; 045 } 046 } 047 private final int jjStartNfa_0(int pos, long active0) 048 { 049 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 050 } 051 private int jjStopAtPos(int pos, int kind) 052 { 053 jjmatchedKind = kind; 054 jjmatchedPos = pos; 055 return pos + 1; 056 } 057 private int jjMoveStringLiteralDfa0_0() 058 { 059 switch(curChar) 060 { 061 case 34: 062 return jjStartNfaWithStates_0(0, 15, 14); 063 case 40: 064 return jjStopAtPos(0, 5); 065 case 41: 066 return jjStopAtPos(0, 6); 067 case 44: 068 return jjStopAtPos(0, 7); 069 case 59: 070 return jjStopAtPos(0, 10); 071 case 60: 072 jjmatchedKind = 12; 073 return jjMoveStringLiteralDfa1_0(0x4000L); 074 case 61: 075 return jjStopAtPos(0, 11); 076 case 62: 077 return jjStartNfaWithStates_0(0, 13, 8); 078 case 92: 079 return jjMoveStringLiteralDfa1_0(0x800000L); 080 case 123: 081 return jjStopAtPos(0, 8); 082 case 125: 083 return jjStopAtPos(0, 9); 084 default : 085 return jjMoveNfa_0(0, 0); 086 } 087 } 088 private int jjMoveStringLiteralDfa1_0(long active0) 089 { 090 try { curChar = input_stream.readChar(); } 091 catch(java.io.IOException e) { 092 jjStopStringLiteralDfa_0(0, active0); 093 return 1; 094 } 095 switch(curChar) 096 { 097 case 34: 098 if ((active0 & 0x800000L) != 0L) 099 return jjStopAtPos(1, 23); 100 break; 101 case 42: 102 return jjMoveStringLiteralDfa2_0(active0, 0x4000L); 103 default : 104 break; 105 } 106 return jjStartNfa_0(0, active0); 107 } 108 private int jjMoveStringLiteralDfa2_0(long old0, long active0) 109 { 110 if (((active0 &= old0)) == 0L) 111 return jjStartNfa_0(0, old0); 112 try { curChar = input_stream.readChar(); } 113 catch(java.io.IOException e) { 114 jjStopStringLiteralDfa_0(1, active0); 115 return 2; 116 } 117 switch(curChar) 118 { 119 case 68: 120 if ((active0 & 0x4000L) != 0L) 121 return jjStartNfaWithStates_0(2, 14, 15); 122 break; 123 default : 124 break; 125 } 126 return jjStartNfa_0(1, active0); 127 } 128 private int jjStartNfaWithStates_0(int pos, int kind, int state) 129 { 130 jjmatchedKind = kind; 131 jjmatchedPos = pos; 132 try { curChar = input_stream.readChar(); } 133 catch(java.io.IOException e) { return pos + 1; } 134 return jjMoveNfa_0(state, pos + 1); 135 } 136 static final long[] jjbitVec0 = { 137 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 138 }; 139 private int jjMoveNfa_0(int startState, int curPos) 140 { 141 int startsAt = 0; 142 jjnewStateCnt = 14; 143 int i = 1; 144 jjstateSet[0] = startState; 145 int kind = 0x7fffffff; 146 for (;;) 147 { 148 if (++jjround == 0x7fffffff) 149 ReInitRounds(); 150 if (curChar < 64) 151 { 152 long l = 1L << curChar; 153 do 154 { 155 switch(jjstateSet[--i]) 156 { 157 case 15: 158 if ((0xd7ffecfaffffd9ffL & l) != 0L) 159 { 160 if (kind > 21) 161 kind = 21; 162 jjCheckNAdd(8); 163 } 164 if ((0x7ff280100000000L & l) != 0L) 165 jjCheckNAddTwoStates(4, 5); 166 else if (curChar == 62) 167 { 168 if (kind > 20) 169 kind = 20; 170 } 171 break; 172 case 6: 173 if ((0xd7ffecfaffffd9ffL & l) != 0L) 174 { 175 if (kind > 21) 176 kind = 21; 177 jjCheckNAdd(8); 178 } 179 if ((0x3ff000100002600L & l) != 0L) 180 jjCheckNAddTwoStates(1, 2); 181 else if (curChar == 42) 182 jjstateSet[jjnewStateCnt++] = 3; 183 else if (curChar == 62) 184 { 185 if (kind > 19) 186 kind = 19; 187 } 188 break; 189 case 14: 190 if ((0xfffffffbffffffffL & l) != 0L) 191 jjCheckNAddStates(0, 2); 192 else if (curChar == 34) 193 { 194 if (kind > 22) 195 kind = 22; 196 } 197 break; 198 case 3: 199 case 8: 200 if ((0xd7ffecfaffffd9ffL & l) == 0L) 201 break; 202 if (kind > 21) 203 kind = 21; 204 jjCheckNAdd(8); 205 break; 206 case 0: 207 if ((0xd7ffecfaffffd9ffL & l) != 0L) 208 { 209 if (kind > 21) 210 kind = 21; 211 jjCheckNAdd(8); 212 } 213 else if (curChar == 34) 214 jjCheckNAddStates(0, 2); 215 if (curChar == 60) 216 jjstateSet[jjnewStateCnt++] = 6; 217 if (curChar == 60) 218 jjCheckNAddTwoStates(1, 2); 219 break; 220 case 1: 221 if ((0x3ff000100002600L & l) != 0L) 222 jjCheckNAddTwoStates(1, 2); 223 break; 224 case 2: 225 if (curChar == 62 && kind > 19) 226 kind = 19; 227 break; 228 case 4: 229 if ((0x7ff280100000000L & l) != 0L) 230 jjCheckNAddTwoStates(4, 5); 231 break; 232 case 5: 233 if (curChar == 62 && kind > 20) 234 kind = 20; 235 break; 236 case 7: 237 if (curChar == 60) 238 jjstateSet[jjnewStateCnt++] = 6; 239 break; 240 case 9: 241 case 11: 242 if (curChar == 34) 243 jjCheckNAddStates(0, 2); 244 break; 245 case 10: 246 if ((0xfffffffbffffffffL & l) != 0L) 247 jjCheckNAddStates(0, 2); 248 break; 249 case 13: 250 if (curChar == 34 && kind > 22) 251 kind = 22; 252 break; 253 default : break; 254 } 255 } while(i != startsAt); 256 } 257 else if (curChar < 128) 258 { 259 long l = 1L << (curChar & 077); 260 do 261 { 262 switch(jjstateSet[--i]) 263 { 264 case 15: 265 if ((0xd7ffffffffffffffL & l) != 0L) 266 { 267 if (kind > 21) 268 kind = 21; 269 jjCheckNAdd(8); 270 } 271 if (curChar == 90) 272 jjCheckNAddTwoStates(4, 5); 273 break; 274 case 6: 275 if ((0xd7ffffffffffffffL & l) != 0L) 276 { 277 if (kind > 21) 278 kind = 21; 279 jjCheckNAdd(8); 280 } 281 if ((0x7e0000007eL & l) != 0L) 282 jjCheckNAddTwoStates(1, 2); 283 break; 284 case 14: 285 jjCheckNAddStates(0, 2); 286 if (curChar == 92) 287 jjstateSet[jjnewStateCnt++] = 11; 288 break; 289 case 3: 290 if ((0xd7ffffffffffffffL & l) != 0L) 291 { 292 if (kind > 21) 293 kind = 21; 294 jjCheckNAdd(8); 295 } 296 if (curChar == 68) 297 jjCheckNAddTwoStates(4, 5); 298 break; 299 case 0: 300 case 8: 301 if ((0xd7ffffffffffffffL & l) == 0L) 302 break; 303 if (kind > 21) 304 kind = 21; 305 jjCheckNAdd(8); 306 break; 307 case 1: 308 if ((0x7e0000007eL & l) != 0L) 309 jjCheckNAddTwoStates(1, 2); 310 break; 311 case 4: 312 if (curChar == 90) 313 jjCheckNAddTwoStates(4, 5); 314 break; 315 case 10: 316 jjCheckNAddStates(0, 2); 317 break; 318 case 12: 319 if (curChar == 92) 320 jjstateSet[jjnewStateCnt++] = 11; 321 break; 322 default : break; 323 } 324 } while(i != startsAt); 325 } 326 else 327 { 328 int i2 = (curChar & 0xff) >> 6; 329 long l2 = 1L << (curChar & 077); 330 do 331 { 332 switch(jjstateSet[--i]) 333 { 334 case 15: 335 case 8: 336 if ((jjbitVec0[i2] & l2) == 0L) 337 break; 338 if (kind > 21) 339 kind = 21; 340 jjCheckNAdd(8); 341 break; 342 case 6: 343 if ((jjbitVec0[i2] & l2) == 0L) 344 break; 345 if (kind > 21) 346 kind = 21; 347 jjCheckNAdd(8); 348 break; 349 case 14: 350 case 10: 351 if ((jjbitVec0[i2] & l2) != 0L) 352 jjCheckNAddStates(0, 2); 353 break; 354 case 3: 355 if ((jjbitVec0[i2] & l2) == 0L) 356 break; 357 if (kind > 21) 358 kind = 21; 359 jjCheckNAdd(8); 360 break; 361 case 0: 362 if ((jjbitVec0[i2] & l2) == 0L) 363 break; 364 if (kind > 21) 365 kind = 21; 366 jjCheckNAdd(8); 367 break; 368 default : break; 369 } 370 } while(i != startsAt); 371 } 372 if (kind != 0x7fffffff) 373 { 374 jjmatchedKind = kind; 375 jjmatchedPos = curPos; 376 kind = 0x7fffffff; 377 } 378 ++curPos; 379 if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt))) 380 return curPos; 381 try { curChar = input_stream.readChar(); } 382 catch(java.io.IOException e) { return curPos; } 383 } 384 } 385 static final int[] jjnextStates = { 386 10, 12, 13, 387 }; 388 389 /** Token literal values. */ 390 public static final String[] jjstrLiteralImages = { 391 "", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75", 392 "\74", "\76", "\74\52\104", "\42", null, null, null, null, null, null, null, 393 "\134\42", }; 394 395 /** Lexer state names. */ 396 public static final String[] lexStateNames = { 397 "DEFAULT", 398 }; 399 static final long[] jjtoToken = { 400 0xf8ffe1L, 401 }; 402 static final long[] jjtoSkip = { 403 0x1eL, 404 }; 405 protected SimpleCharStream input_stream; 406 private final int[] jjrounds = new int[14]; 407 private final int[] jjstateSet = new int[28]; 408 protected char curChar; 409 /** Constructor. */ 410 public PropertyListParserTokenManager(SimpleCharStream stream){ 411 if (SimpleCharStream.staticFlag) 412 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 413 input_stream = stream; 414 } 415 416 /** Constructor. */ 417 public PropertyListParserTokenManager(SimpleCharStream stream, int lexState){ 418 this(stream); 419 SwitchTo(lexState); 420 } 421 422 /** Reinitialise parser. */ 423 public void ReInit(SimpleCharStream stream) 424 { 425 jjmatchedPos = jjnewStateCnt = 0; 426 curLexState = defaultLexState; 427 input_stream = stream; 428 ReInitRounds(); 429 } 430 private void ReInitRounds() 431 { 432 int i; 433 jjround = 0x80000001; 434 for (i = 14; i-- > 0;) 435 jjrounds[i] = 0x80000000; 436 } 437 438 /** Reinitialise parser. */ 439 public void ReInit(SimpleCharStream stream, int lexState) 440 { 441 ReInit(stream); 442 SwitchTo(lexState); 443 } 444 445 /** Switch to specified lex state. */ 446 public void SwitchTo(int lexState) 447 { 448 if (lexState >= 1 || lexState < 0) 449 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 450 else 451 curLexState = lexState; 452 } 453 454 protected Token jjFillToken() 455 { 456 final Token t; 457 final String curTokenImage; 458 final int beginLine; 459 final int endLine; 460 final int beginColumn; 461 final int endColumn; 462 String im = jjstrLiteralImages[jjmatchedKind]; 463 curTokenImage = (im == null) ? input_stream.GetImage() : im; 464 beginLine = input_stream.getBeginLine(); 465 beginColumn = input_stream.getBeginColumn(); 466 endLine = input_stream.getEndLine(); 467 endColumn = input_stream.getEndColumn(); 468 t = Token.newToken(jjmatchedKind, curTokenImage); 469 470 t.beginLine = beginLine; 471 t.endLine = endLine; 472 t.beginColumn = beginColumn; 473 t.endColumn = endColumn; 474 475 return t; 476 } 477 478 int curLexState = 0; 479 int defaultLexState = 0; 480 int jjnewStateCnt; 481 int jjround; 482 int jjmatchedPos; 483 int jjmatchedKind; 484 485 /** Get the next Token. */ 486 public Token getNextToken() 487 { 488 Token matchedToken; 489 int curPos = 0; 490 491 EOFLoop : 492 for (;;) 493 { 494 try 495 { 496 curChar = input_stream.BeginToken(); 497 } 498 catch(java.io.IOException e) 499 { 500 jjmatchedKind = 0; 501 matchedToken = jjFillToken(); 502 return matchedToken; 503 } 504 505 try { input_stream.backup(0); 506 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) 507 curChar = input_stream.BeginToken(); 508 } 509 catch (java.io.IOException e1) { continue EOFLoop; } 510 jjmatchedKind = 0x7fffffff; 511 jjmatchedPos = 0; 512 curPos = jjMoveStringLiteralDfa0_0(); 513 if (jjmatchedKind != 0x7fffffff) 514 { 515 if (jjmatchedPos + 1 < curPos) 516 input_stream.backup(curPos - jjmatchedPos - 1); 517 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 518 { 519 matchedToken = jjFillToken(); 520 return matchedToken; 521 } 522 else 523 { 524 continue EOFLoop; 525 } 526 } 527 int error_line = input_stream.getEndLine(); 528 int error_column = input_stream.getEndColumn(); 529 String error_after = null; 530 boolean EOFSeen = false; 531 try { input_stream.readChar(); input_stream.backup(1); } 532 catch (java.io.IOException e1) { 533 EOFSeen = true; 534 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 535 if (curChar == '\n' || curChar == '\r') { 536 error_line++; 537 error_column = 0; 538 } 539 else 540 error_column++; 541 } 542 if (!EOFSeen) { 543 input_stream.backup(1); 544 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 545 } 546 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 547 } 548 } 549 550 private void jjCheckNAdd(int state) 551 { 552 if (jjrounds[state] != jjround) 553 { 554 jjstateSet[jjnewStateCnt++] = state; 555 jjrounds[state] = jjround; 556 } 557 } 558 private void jjAddStates(int start, int end) 559 { 560 do { 561 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 562 } while (start++ != end); 563 } 564 private void jjCheckNAddTwoStates(int state1, int state2) 565 { 566 jjCheckNAdd(state1); 567 jjCheckNAdd(state2); 568 } 569 570 private void jjCheckNAddStates(int start, int end) 571 { 572 do { 573 jjCheckNAdd(jjnextStates[start]); 574 } while (start++ != end); 575 } 576 577 }