1. /* Generated By:JavaCC: Do not edit this line. ELParserTokenManager.java */
  2. package org.apache.commons.el.parser;
  3. import org.apache.commons.el.*;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. public class ELParserTokenManager implements ELParserConstants
  7. {
  8. public java.io.PrintStream debugStream = System.out;
  9. public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  10. private final int jjStopStringLiteralDfa_0(int pos, long active0)
  11. {
  12. switch (pos)
  13. {
  14. case 0:
  15. if ((active0 & 0x4L) != 0L)
  16. {
  17. jjmatchedKind = 1;
  18. return 2;
  19. }
  20. return -1;
  21. default :
  22. return -1;
  23. }
  24. }
  25. private final int jjStartNfa_0(int pos, long active0)
  26. {
  27. return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  28. }
  29. private final int jjStopAtPos(int pos, int kind)
  30. {
  31. jjmatchedKind = kind;
  32. jjmatchedPos = pos;
  33. return pos + 1;
  34. }
  35. private final int jjStartNfaWithStates_0(int pos, int kind, int state)
  36. {
  37. jjmatchedKind = kind;
  38. jjmatchedPos = pos;
  39. try { curChar = input_stream.readChar(); }
  40. catch(java.io.IOException e) { return pos + 1; }
  41. return jjMoveNfa_0(state, pos + 1);
  42. }
  43. private final int jjMoveStringLiteralDfa0_0()
  44. {
  45. switch(curChar)
  46. {
  47. case 36:
  48. return jjMoveStringLiteralDfa1_0(0x4L);
  49. default :
  50. return jjMoveNfa_0(1, 0);
  51. }
  52. }
  53. private final int jjMoveStringLiteralDfa1_0(long active0)
  54. {
  55. try { curChar = input_stream.readChar(); }
  56. catch(java.io.IOException e) {
  57. jjStopStringLiteralDfa_0(0, active0);
  58. return 1;
  59. }
  60. switch(curChar)
  61. {
  62. case 123:
  63. if ((active0 & 0x4L) != 0L)
  64. return jjStopAtPos(1, 2);
  65. break;
  66. default :
  67. break;
  68. }
  69. return jjStartNfa_0(0, active0);
  70. }
  71. private final void jjCheckNAdd(int state)
  72. {
  73. if (jjrounds[state] != jjround)
  74. {
  75. jjstateSet[jjnewStateCnt++] = state;
  76. jjrounds[state] = jjround;
  77. }
  78. }
  79. private final void jjAddStates(int start, int end)
  80. {
  81. do {
  82. jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  83. } while (start++ != end);
  84. }
  85. private final void jjCheckNAddTwoStates(int state1, int state2)
  86. {
  87. jjCheckNAdd(state1);
  88. jjCheckNAdd(state2);
  89. }
  90. private final void jjCheckNAddStates(int start, int end)
  91. {
  92. do {
  93. jjCheckNAdd(jjnextStates[start]);
  94. } while (start++ != end);
  95. }
  96. private final void jjCheckNAddStates(int start)
  97. {
  98. jjCheckNAdd(jjnextStates[start]);
  99. jjCheckNAdd(jjnextStates[start + 1]);
  100. }
  101. static final long[] jjbitVec0 = {
  102. 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  103. };
  104. static final long[] jjbitVec2 = {
  105. 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  106. };
  107. private final int jjMoveNfa_0(int startState, int curPos)
  108. {
  109. int[] nextStates;
  110. int startsAt = 0;
  111. jjnewStateCnt = 3;
  112. int i = 1;
  113. jjstateSet[0] = startState;
  114. int j, kind = 0x7fffffff;
  115. for (;;)
  116. {
  117. if (++jjround == 0x7fffffff)
  118. ReInitRounds();
  119. if (curChar < 64)
  120. {
  121. long l = 1L << curChar;
  122. MatchLoop: do
  123. {
  124. switch(jjstateSet[--i])
  125. {
  126. case 1:
  127. if ((0xffffffefffffffffL & l) != 0L)
  128. {
  129. if (kind > 1)
  130. kind = 1;
  131. jjCheckNAdd(0);
  132. }
  133. else if (curChar == 36)
  134. {
  135. if (kind > 1)
  136. kind = 1;
  137. jjCheckNAdd(2);
  138. }
  139. break;
  140. case 0:
  141. if ((0xffffffefffffffffL & l) == 0L)
  142. break;
  143. if (kind > 1)
  144. kind = 1;
  145. jjCheckNAdd(0);
  146. break;
  147. case 2:
  148. if ((0xffffffefffffffffL & l) == 0L)
  149. break;
  150. if (kind > 1)
  151. kind = 1;
  152. jjCheckNAdd(2);
  153. break;
  154. default : break;
  155. }
  156. } while(i != startsAt);
  157. }
  158. else if (curChar < 128)
  159. {
  160. long l = 1L << (curChar & 077);
  161. MatchLoop: do
  162. {
  163. switch(jjstateSet[--i])
  164. {
  165. case 1:
  166. case 0:
  167. if (kind > 1)
  168. kind = 1;
  169. jjCheckNAdd(0);
  170. break;
  171. case 2:
  172. if ((0xf7ffffffffffffffL & l) == 0L)
  173. break;
  174. if (kind > 1)
  175. kind = 1;
  176. jjstateSet[jjnewStateCnt++] = 2;
  177. break;
  178. default : break;
  179. }
  180. } while(i != startsAt);
  181. }
  182. else
  183. {
  184. int hiByte = (int)(curChar >> 8);
  185. int i1 = hiByte >> 6;
  186. long l1 = 1L << (hiByte & 077);
  187. int i2 = (curChar & 0xff) >> 6;
  188. long l2 = 1L << (curChar & 077);
  189. MatchLoop: do
  190. {
  191. switch(jjstateSet[--i])
  192. {
  193. case 1:
  194. case 0:
  195. if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
  196. break;
  197. if (kind > 1)
  198. kind = 1;
  199. jjCheckNAdd(0);
  200. break;
  201. case 2:
  202. if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
  203. break;
  204. if (kind > 1)
  205. kind = 1;
  206. jjstateSet[jjnewStateCnt++] = 2;
  207. break;
  208. default : break;
  209. }
  210. } while(i != startsAt);
  211. }
  212. if (kind != 0x7fffffff)
  213. {
  214. jjmatchedKind = kind;
  215. jjmatchedPos = curPos;
  216. kind = 0x7fffffff;
  217. }
  218. ++curPos;
  219. if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
  220. return curPos;
  221. try { curChar = input_stream.readChar(); }
  222. catch(java.io.IOException e) { return curPos; }
  223. }
  224. }
  225. private final int jjStopStringLiteralDfa_1(int pos, long active0)
  226. {
  227. switch (pos)
  228. {
  229. case 0:
  230. if ((active0 & 0x10000L) != 0L)
  231. return 1;
  232. if ((active0 & 0x1568015547000L) != 0L)
  233. {
  234. jjmatchedKind = 50;
  235. return 6;
  236. }
  237. return -1;
  238. case 1:
  239. if ((active0 & 0x400015540000L) != 0L)
  240. return 6;
  241. if ((active0 & 0x1168000007000L) != 0L)
  242. {
  243. jjmatchedKind = 50;
  244. jjmatchedPos = 1;
  245. return 6;
  246. }
  247. return -1;
  248. case 2:
  249. if ((active0 & 0x168000000000L) != 0L)
  250. return 6;
  251. if ((active0 & 0x1000000007000L) != 0L)
  252. {
  253. jjmatchedKind = 50;
  254. jjmatchedPos = 2;
  255. return 6;
  256. }
  257. return -1;
  258. case 3:
  259. if ((active0 & 0x1000000002000L) != 0L)
  260. {
  261. jjmatchedKind = 50;
  262. jjmatchedPos = 3;
  263. return 6;
  264. }
  265. if ((active0 & 0x5000L) != 0L)
  266. return 6;
  267. return -1;
  268. default :
  269. return -1;
  270. }
  271. }
  272. private final int jjStartNfa_1(int pos, long active0)
  273. {
  274. return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
  275. }
  276. private final int jjStartNfaWithStates_1(int pos, int kind, int state)
  277. {
  278. jjmatchedKind = kind;
  279. jjmatchedPos = pos;
  280. try { curChar = input_stream.readChar(); }
  281. catch(java.io.IOException e) { return pos + 1; }
  282. return jjMoveNfa_1(state, pos + 1);
  283. }
  284. private final int jjMoveStringLiteralDfa0_1()
  285. {
  286. switch(curChar)
  287. {
  288. case 33:
  289. jjmatchedKind = 43;
  290. return jjMoveStringLiteralDfa1_1(0x8000000L);
  291. case 37:
  292. return jjStopAtPos(0, 40);
  293. case 38:
  294. return jjMoveStringLiteralDfa1_1(0x200000000000L);
  295. case 40:
  296. return jjStopAtPos(0, 29);
  297. case 41:
  298. return jjStopAtPos(0, 30);
  299. case 42:
  300. return jjStopAtPos(0, 37);
  301. case 43:
  302. return jjStopAtPos(0, 35);
  303. case 44:
  304. return jjStopAtPos(0, 31);
  305. case 45:
  306. return jjStopAtPos(0, 36);
  307. case 46:
  308. return jjStartNfaWithStates_1(0, 16, 1);
  309. case 47:
  310. return jjStopAtPos(0, 38);
  311. case 58:
  312. return jjStopAtPos(0, 32);
  313. case 60:
  314. jjmatchedKind = 19;
  315. return jjMoveStringLiteralDfa1_1(0x800000L);
  316. case 61:
  317. return jjMoveStringLiteralDfa1_1(0x200000L);
  318. case 62:
  319. jjmatchedKind = 17;
  320. return jjMoveStringLiteralDfa1_1(0x2000000L);
  321. case 63:
  322. return jjStopAtPos(0, 49);
  323. case 91:
  324. return jjStopAtPos(0, 33);
  325. case 93:
  326. return jjStopAtPos(0, 34);
  327. case 97:
  328. return jjMoveStringLiteralDfa1_1(0x100000000000L);
  329. case 100:
  330. return jjMoveStringLiteralDfa1_1(0x8000000000L);
  331. case 101:
  332. return jjMoveStringLiteralDfa1_1(0x1000000400000L);
  333. case 102:
  334. return jjMoveStringLiteralDfa1_1(0x2000L);
  335. case 103:
  336. return jjMoveStringLiteralDfa1_1(0x4040000L);
  337. case 108:
  338. return jjMoveStringLiteralDfa1_1(0x1100000L);
  339. case 109:
  340. return jjMoveStringLiteralDfa1_1(0x20000000000L);
  341. case 110:
  342. return jjMoveStringLiteralDfa1_1(0x40010004000L);
  343. case 111:
  344. return jjMoveStringLiteralDfa1_1(0x400000000000L);
  345. case 116:
  346. return jjMoveStringLiteralDfa1_1(0x1000L);
  347. case 124:
  348. return jjMoveStringLiteralDfa1_1(0x800000000000L);
  349. case 125:
  350. return jjStopAtPos(0, 15);
  351. default :
  352. return jjMoveNfa_1(0, 0);
  353. }
  354. }
  355. private final int jjMoveStringLiteralDfa1_1(long active0)
  356. {
  357. try { curChar = input_stream.readChar(); }
  358. catch(java.io.IOException e) {
  359. jjStopStringLiteralDfa_1(0, active0);
  360. return 1;
  361. }
  362. switch(curChar)
  363. {
  364. case 38:
  365. if ((active0 & 0x200000000000L) != 0L)
  366. return jjStopAtPos(1, 45);
  367. break;
  368. case 61:
  369. if ((active0 & 0x200000L) != 0L)
  370. return jjStopAtPos(1, 21);
  371. else if ((active0 & 0x800000L) != 0L)
  372. return jjStopAtPos(1, 23);
  373. else if ((active0 & 0x2000000L) != 0L)
  374. return jjStopAtPos(1, 25);
  375. else if ((active0 & 0x8000000L) != 0L)
  376. return jjStopAtPos(1, 27);
  377. break;
  378. case 97:
  379. return jjMoveStringLiteralDfa2_1(active0, 0x2000L);
  380. case 101:
  381. if ((active0 & 0x1000000L) != 0L)
  382. return jjStartNfaWithStates_1(1, 24, 6);
  383. else if ((active0 & 0x4000000L) != 0L)
  384. return jjStartNfaWithStates_1(1, 26, 6);
  385. else if ((active0 & 0x10000000L) != 0L)
  386. return jjStartNfaWithStates_1(1, 28, 6);
  387. break;
  388. case 105:
  389. return jjMoveStringLiteralDfa2_1(active0, 0x8000000000L);
  390. case 109:
  391. return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000L);
  392. case 110:
  393. return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L);
  394. case 111:
  395. return jjMoveStringLiteralDfa2_1(active0, 0x60000000000L);
  396. case 113:
  397. if ((active0 & 0x400000L) != 0L)
  398. return jjStartNfaWithStates_1(1, 22, 6);
  399. break;
  400. case 114:
  401. if ((active0 & 0x400000000000L) != 0L)
  402. return jjStartNfaWithStates_1(1, 46, 6);
  403. return jjMoveStringLiteralDfa2_1(active0, 0x1000L);
  404. case 116:
  405. if ((active0 & 0x40000L) != 0L)
  406. return jjStartNfaWithStates_1(1, 18, 6);
  407. else if ((active0 & 0x100000L) != 0L)
  408. return jjStartNfaWithStates_1(1, 20, 6);
  409. break;
  410. case 117:
  411. return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
  412. case 124:
  413. if ((active0 & 0x800000000000L) != 0L)
  414. return jjStopAtPos(1, 47);
  415. break;
  416. default :
  417. break;
  418. }
  419. return jjStartNfa_1(0, active0);
  420. }
  421. private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
  422. {
  423. if (((active0 &= old0)) == 0L)
  424. return jjStartNfa_1(0, old0);
  425. try { curChar = input_stream.readChar(); }
  426. catch(java.io.IOException e) {
  427. jjStopStringLiteralDfa_1(1, active0);
  428. return 2;
  429. }
  430. switch(curChar)
  431. {
  432. case 100:
  433. if ((active0 & 0x20000000000L) != 0L)
  434. return jjStartNfaWithStates_1(2, 41, 6);
  435. else if ((active0 & 0x100000000000L) != 0L)
  436. return jjStartNfaWithStates_1(2, 44, 6);
  437. break;
  438. case 108:
  439. return jjMoveStringLiteralDfa3_1(active0, 0x6000L);
  440. case 112:
  441. return jjMoveStringLiteralDfa3_1(active0, 0x1000000000000L);
  442. case 116:
  443. if ((active0 & 0x40000000000L) != 0L)
  444. return jjStartNfaWithStates_1(2, 42, 6);
  445. break;
  446. case 117:
  447. return jjMoveStringLiteralDfa3_1(active0, 0x1000L);
  448. case 118:
  449. if ((active0 & 0x8000000000L) != 0L)
  450. return jjStartNfaWithStates_1(2, 39, 6);
  451. break;
  452. default :
  453. break;
  454. }
  455. return jjStartNfa_1(1, active0);
  456. }
  457. private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
  458. {
  459. if (((active0 &= old0)) == 0L)
  460. return jjStartNfa_1(1, old0);
  461. try { curChar = input_stream.readChar(); }
  462. catch(java.io.IOException e) {
  463. jjStopStringLiteralDfa_1(2, active0);
  464. return 3;
  465. }
  466. switch(curChar)
  467. {
  468. case 101:
  469. if ((active0 & 0x1000L) != 0L)
  470. return jjStartNfaWithStates_1(3, 12, 6);
  471. break;
  472. case 108:
  473. if ((active0 & 0x4000L) != 0L)
  474. return jjStartNfaWithStates_1(3, 14, 6);
  475. break;
  476. case 115:
  477. return jjMoveStringLiteralDfa4_1(active0, 0x2000L);
  478. case 116:
  479. return jjMoveStringLiteralDfa4_1(active0, 0x1000000000000L);
  480. default :
  481. break;
  482. }
  483. return jjStartNfa_1(2, active0);
  484. }
  485. private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
  486. {
  487. if (((active0 &= old0)) == 0L)
  488. return jjStartNfa_1(2, old0);
  489. try { curChar = input_stream.readChar(); }
  490. catch(java.io.IOException e) {
  491. jjStopStringLiteralDfa_1(3, active0);
  492. return 4;
  493. }
  494. switch(curChar)
  495. {
  496. case 101:
  497. if ((active0 & 0x2000L) != 0L)
  498. return jjStartNfaWithStates_1(4, 13, 6);
  499. break;
  500. case 121:
  501. if ((active0 & 0x1000000000000L) != 0L)
  502. return jjStartNfaWithStates_1(4, 48, 6);
  503. break;
  504. default :
  505. break;
  506. }
  507. return jjStartNfa_1(3, active0);
  508. }
  509. static final long[] jjbitVec3 = {
  510. 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
  511. };
  512. static final long[] jjbitVec4 = {
  513. 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
  514. };
  515. static final long[] jjbitVec5 = {
  516. 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  517. };
  518. static final long[] jjbitVec6 = {
  519. 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
  520. };
  521. static final long[] jjbitVec7 = {
  522. 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
  523. };
  524. static final long[] jjbitVec8 = {
  525. 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
  526. };
  527. private final int jjMoveNfa_1(int startState, int curPos)
  528. {
  529. int[] nextStates;
  530. int startsAt = 0;
  531. jjnewStateCnt = 35;
  532. int i = 1;
  533. jjstateSet[0] = startState;
  534. int j, kind = 0x7fffffff;
  535. for (;;)
  536. {
  537. if (++jjround == 0x7fffffff)
  538. ReInitRounds();
  539. if (curChar < 64)
  540. {
  541. long l = 1L << curChar;
  542. MatchLoop: do
  543. {
  544. switch(jjstateSet[--i])
  545. {
  546. case 0:
  547. if ((0x3ff000000000000L & l) != 0L)
  548. {
  549. if (kind > 7)
  550. kind = 7;
  551. jjCheckNAddStates(0, 4);
  552. }
  553. else if ((0x1800000000L & l) != 0L)
  554. {
  555. if (kind > 50)
  556. kind = 50;
  557. jjCheckNAdd(6);
  558. }
  559. else if (curChar == 39)
  560. jjCheckNAddStates(5, 9);
  561. else if (curChar == 34)
  562. jjCheckNAddStates(10, 14);
  563. else if (curChar == 46)
  564. jjCheckNAdd(1);
  565. break;
  566. case 1:
  567. if ((0x3ff000000000000L & l) == 0L)
  568. break;
  569. if (kind > 8)
  570. kind = 8;
  571. jjCheckNAddTwoStates(1, 2);
  572. break;
  573. case 3:
  574. if ((0x280000000000L & l) != 0L)
  575. jjCheckNAdd(4);
  576. break;
  577. case 4:
  578. if ((0x3ff000000000000L & l) == 0L)
  579. break;
  580. if (kind > 8)
  581. kind = 8;
  582. jjCheckNAdd(4);
  583. break;
  584. case 5:
  585. if ((0x1800000000L & l) == 0L)
  586. break;
  587. if (kind > 50)
  588. kind = 50;
  589. jjCheckNAdd(6);
  590. break;
  591. case 6:
  592. if ((0x3ff001000000000L & l) == 0L)
  593. break;
  594. if (kind > 50)
  595. kind = 50;
  596. jjCheckNAdd(6);
  597. break;
  598. case 7:
  599. if ((0x3ff000000000000L & l) == 0L)
  600. break;
  601. if (kind > 7)
  602. kind = 7;
  603. jjCheckNAddStates(0, 4);
  604. break;
  605. case 8:
  606. if ((0x3ff000000000000L & l) == 0L)
  607. break;
  608. if (kind > 7)
  609. kind = 7;
  610. jjCheckNAdd(8);
  611. break;
  612. case 9:
  613. if ((0x3ff000000000000L & l) != 0L)
  614. jjCheckNAddTwoStates(9, 10);
  615. break;
  616. case 10:
  617. if (curChar != 46)
  618. break;
  619. if (kind > 8)
  620. kind = 8;
  621. jjCheckNAddTwoStates(11, 12);
  622. break;
  623. case 11:
  624. if ((0x3ff000000000000L & l) == 0L)
  625. break;
  626. if (kind > 8)
  627. kind = 8;
  628. jjCheckNAddTwoStates(11, 12);
  629. break;
  630. case 13:
  631. if ((0x280000000000L & l) != 0L)
  632. jjCheckNAdd(14);
  633. break;
  634. case 14:
  635. if ((0x3ff000000000000L & l) == 0L)
  636. break;
  637. if (kind > 8)
  638. kind = 8;
  639. jjCheckNAdd(14);
  640. break;
  641. case 15:
  642. if ((0x3ff000000000000L & l) != 0L)
  643. jjCheckNAddTwoStates(15, 16);
  644. break;
  645. case 17:
  646. if ((0x280000000000L & l) != 0L)
  647. jjCheckNAdd(18);
  648. break;
  649. case 18:
  650. if ((0x3ff000000000000L & l) == 0L)
  651. break;
  652. if (kind > 8)
  653. kind = 8;
  654. jjCheckNAdd(18);
  655. break;
  656. case 19:
  657. if (curChar == 34)
  658. jjCheckNAddStates(10, 14);
  659. break;
  660. case 20:
  661. if ((0xfffffffbffffffffL & l) != 0L)
  662. jjCheckNAddStates(15, 17);
  663. break;
  664. case 22:
  665. if (curChar == 34)
  666. jjCheckNAddStates(15, 17);
  667. break;
  668. case 23:
  669. if (curChar == 34 && kind > 10)
  670. kind = 10;
  671. break;
  672. case 24:
  673. if ((0xfffffffbffffffffL & l) != 0L)
  674. jjCheckNAddTwoStates(24, 25);
  675. break;
  676. case 26:
  677. if ((0xfffffffbffffffffL & l) != 0L && kind > 11)
  678. kind = 11;
  679. break;
  680. case 27:
  681. if (curChar == 39)
  682. jjCheckNAddStates(5, 9);
  683. break;
  684. case 28:
  685. if ((0xffffff7fffffffffL & l) != 0L)
  686. jjCheckNAddStates(18, 20);
  687. break;
  688. case 30:
  689. if (curChar == 39)
  690. jjCheckNAddStates(18, 20);
  691. break;
  692. case 31:
  693. if (curChar == 39 && kind > 10)
  694. kind = 10;
  695. break;
  696. case 32:
  697. if ((0xffffff7fffffffffL & l) != 0L)
  698. jjCheckNAddTwoStates(32, 33);
  699. break;
  700. case 34:
  701. if ((0xffffff7fffffffffL & l) != 0L && kind > 11)
  702. kind = 11;
  703. break;
  704. default : break;
  705. }
  706. } while(i != startsAt);
  707. }
  708. else if (curChar < 128)
  709. {
  710. long l = 1L << (curChar & 077);
  711. MatchLoop: do
  712. {
  713. switch(jjstateSet[--i])
  714. {
  715. case 0:
  716. case 6:
  717. if ((0x7fffffe87fffffeL & l) == 0L)
  718. break;
  719. if (kind > 50)
  720. kind = 50;
  721. jjCheckNAdd(6);
  722. break;
  723. case 2:
  724. if ((0x2000000020L & l) != 0L)
  725. jjAddStates(21, 22);
  726. break;
  727. case 12:
  728. if ((0x2000000020L & l) != 0L)
  729. jjAddStates(23, 24);
  730. break;
  731. case 16:
  732. if ((0x2000000020L & l) != 0L)
  733. jjAddStates(25, 26);
  734. break;
  735. case 20:
  736. if ((0xffffffffefffffffL & l) != 0L)
  737. jjCheckNAddStates(15, 17);
  738. break;
  739. case 21:
  740. if (curChar == 92)
  741. jjstateSet[jjnewStateCnt++] = 22;
  742. break;
  743. case 22:
  744. if (curChar == 92)
  745. jjCheckNAddStates(15, 17);
  746. break;
  747. case 24:
  748. if ((0xffffffffefffffffL & l) != 0L)
  749. jjAddStates(27, 28);
  750. break;
  751. case 25:
  752. if (curChar == 92)
  753. jjstateSet[jjnewStateCnt++] = 26;
  754. break;
  755. case 26:
  756. case 34:
  757. if ((0xffffffffefffffffL & l) != 0L && kind > 11)
  758. kind = 11;
  759. break;
  760. case 28:
  761. if ((0xffffffffefffffffL & l) != 0L)
  762. jjCheckNAddStates(18, 20);
  763. break;
  764. case 29:
  765. if (curChar == 92)
  766. jjstateSet[jjnewStateCnt++] = 30;
  767. break;
  768. case 30:
  769. if (curChar == 92)
  770. jjCheckNAddStates(18, 20);
  771. break;
  772. case 32:
  773. if ((0xffffffffefffffffL & l) != 0L)
  774. jjAddStates(29, 30);
  775. break;
  776. case 33:
  777. if (curChar == 92)
  778. jjstateSet[jjnewStateCnt++] = 34;
  779. break;
  780. default : break;
  781. }
  782. } while(i != startsAt);
  783. }
  784. else
  785. {
  786. int hiByte = (int)(curChar >> 8);
  787. int i1 = hiByte >> 6;
  788. long l1 = 1L << (hiByte & 077);
  789. int i2 = (curChar & 0xff) >> 6;
  790. long l2 = 1L << (curChar & 077);
  791. MatchLoop: do
  792. {
  793. switch(jjstateSet[--i])
  794. {
  795. case 0:
  796. case 6:
  797. if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
  798. break;
  799. if (kind > 50)
  800. kind = 50;
  801. jjCheckNAdd(6);
  802. break;
  803. case 20:
  804. if (jjCanMove_0(hiByte, i1, i2, l1, l2))
  805. jjAddStates(15, 17);
  806. break;
  807. case 24:
  808. if (jjCanMove_0(hiByte, i1, i2, l1, l2))
  809. jjAddStates(27, 28);
  810. break;
  811. case 26:
  812. case 34:
  813. if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 11)
  814. kind = 11;
  815. break;
  816. case 28:
  817. if (jjCanMove_0(hiByte, i1, i2, l1, l2))
  818. jjAddStates(18, 20);
  819. break;
  820. case 32:
  821. if (jjCanMove_0(hiByte, i1, i2, l1, l2))
  822. jjAddStates(29, 30);
  823. break;
  824. default : break;
  825. }
  826. } while(i != startsAt);
  827. }
  828. if (kind != 0x7fffffff)
  829. {
  830. jjmatchedKind = kind;
  831. jjmatchedPos = curPos;
  832. kind = 0x7fffffff;
  833. }
  834. ++curPos;
  835. if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
  836. return curPos;
  837. try { curChar = input_stream.readChar(); }
  838. catch(java.io.IOException e) { return curPos; }
  839. }
  840. }
  841. static final int[] jjnextStates = {
  842. 8, 9, 10, 15, 16, 28, 29, 31, 32, 33, 20, 21, 23, 24, 25, 20,
  843. 21, 23, 28, 29, 31, 3, 4, 13, 14, 17, 18, 24, 25, 32, 33,
  844. };
  845. private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
  846. {
  847. switch(hiByte)
  848. {
  849. case 0:
  850. return ((jjbitVec2[i2] & l2) != 0L);
  851. default :
  852. if ((jjbitVec0[i1] & l1) != 0L)
  853. return true;
  854. return false;
  855. }
  856. }
  857. private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
  858. {
  859. switch(hiByte)
  860. {
  861. case 0:
  862. return ((jjbitVec4[i2] & l2) != 0L);
  863. case 48:
  864. return ((jjbitVec5[i2] & l2) != 0L);
  865. case 49:
  866. return ((jjbitVec6[i2] & l2) != 0L);
  867. case 51:
  868. return ((jjbitVec7[i2] & l2) != 0L);
  869. case 61:
  870. return ((jjbitVec8[i2] & l2) != 0L);
  871. default :
  872. if ((jjbitVec3[i1] & l1) != 0L)
  873. return true;
  874. return false;
  875. }
  876. }
  877. public static final String[] jjstrLiteralImages = {
  878. "", null, "\44\173", null, null, null, null, null, null, null, null, null,
  879. "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\175", "\56", "\76", "\147\164",
  880. "\74", "\154\164", "\75\75", "\145\161", "\74\75", "\154\145", "\76\75", "\147\145",
  881. "\41\75", "\156\145", "\50", "\51", "\54", "\72", "\133", "\135", "\53", "\55", "\52",
  882. "\57", "\144\151\166", "\45", "\155\157\144", "\156\157\164", "\41", "\141\156\144",
  883. "\46\46", "\157\162", "\174\174", "\145\155\160\164\171", "\77", null, null, null, null,
  884. null, };
  885. public static final String[] lexStateNames = {
  886. "DEFAULT",
  887. "IN_EXPRESSION",
  888. };
  889. public static final int[] jjnewLexState = {
  890. -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  891. -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  892. -1, -1, -1, -1, -1,
  893. };
  894. static final long[] jjtoToken = {
  895. 0x47fffffffffd87L,
  896. };
  897. static final long[] jjtoSkip = {
  898. 0x78L,
  899. };
  900. private SimpleCharStream input_stream;
  901. private final int[] jjrounds = new int[35];
  902. private final int[] jjstateSet = new int[70];
  903. protected char curChar;
  904. public ELParserTokenManager(SimpleCharStream stream)
  905. {
  906. if (SimpleCharStream.staticFlag)
  907. throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
  908. input_stream = stream;
  909. }
  910. public ELParserTokenManager(SimpleCharStream stream, int lexState)
  911. {
  912. this(stream);
  913. SwitchTo(lexState);
  914. }
  915. public void ReInit(SimpleCharStream stream)
  916. {
  917. jjmatchedPos = jjnewStateCnt = 0;
  918. curLexState = defaultLexState;
  919. input_stream = stream;
  920. ReInitRounds();
  921. }
  922. private final void ReInitRounds()
  923. {
  924. int i;
  925. jjround = 0x80000001;
  926. for (i = 35; i-- > 0;)
  927. jjrounds[i] = 0x80000000;
  928. }
  929. public void ReInit(SimpleCharStream stream, int lexState)
  930. {
  931. ReInit(stream);
  932. SwitchTo(lexState);
  933. }
  934. public void SwitchTo(int lexState)
  935. {
  936. if (lexState >= 2 || lexState < 0)
  937. throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
  938. else
  939. curLexState = lexState;
  940. }
  941. private final Token jjFillToken()
  942. {
  943. Token t = Token.newToken(jjmatchedKind);
  944. t.kind = jjmatchedKind;
  945. String im = jjstrLiteralImages[jjmatchedKind];
  946. t.image = (im == null) ? input_stream.GetImage() : im;
  947. t.beginLine = input_stream.getBeginLine();
  948. t.beginColumn = input_stream.getBeginColumn();
  949. t.endLine = input_stream.getEndLine();
  950. t.endColumn = input_stream.getEndColumn();
  951. return t;
  952. }
  953. int curLexState = 0;
  954. int defaultLexState = 0;
  955. int jjnewStateCnt;
  956. int jjround;
  957. int jjmatchedPos;
  958. int jjmatchedKind;
  959. public final Token getNextToken()
  960. {
  961. int kind;
  962. Token specialToken = null;
  963. Token matchedToken;
  964. int curPos = 0;
  965. EOFLoop :
  966. for (;;)
  967. {
  968. try
  969. {
  970. curChar = input_stream.BeginToken();
  971. }
  972. catch(java.io.IOException e)
  973. {
  974. jjmatchedKind = 0;
  975. matchedToken = jjFillToken();
  976. return matchedToken;
  977. }
  978. switch(curLexState)
  979. {
  980. case 0:
  981. jjmatchedKind = 0x7fffffff;
  982. jjmatchedPos = 0;
  983. curPos = jjMoveStringLiteralDfa0_0();
  984. break;
  985. case 1:
  986. try { input_stream.backup(0);
  987. while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
  988. curChar = input_stream.BeginToken();
  989. }
  990. catch (java.io.IOException e1) { continue EOFLoop; }
  991. jjmatchedKind = 0x7fffffff;
  992. jjmatchedPos = 0;
  993. curPos = jjMoveStringLiteralDfa0_1();
  994. if (jjmatchedPos == 0 && jjmatchedKind > 54)
  995. {
  996. jjmatchedKind = 54;
  997. }
  998. break;
  999. }
  1000. if (jjmatchedKind != 0x7fffffff)
  1001. {
  1002. if (jjmatchedPos + 1 < curPos)
  1003. input_stream.backup(curPos - jjmatchedPos - 1);
  1004. if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
  1005. {
  1006. matchedToken = jjFillToken();
  1007. if (jjnewLexState[jjmatchedKind] != -1)
  1008. curLexState = jjnewLexState[jjmatchedKind];
  1009. return matchedToken;
  1010. }
  1011. else
  1012. {
  1013. if (jjnewLexState[jjmatchedKind] != -1)
  1014. curLexState = jjnewLexState[jjmatchedKind];
  1015. continue EOFLoop;
  1016. }
  1017. }
  1018. int error_line = input_stream.getEndLine();
  1019. int error_column = input_stream.getEndColumn();
  1020. String error_after = null;
  1021. boolean EOFSeen = false;
  1022. try { input_stream.readChar(); input_stream.backup(1); }
  1023. catch (java.io.IOException e1) {
  1024. EOFSeen = true;
  1025. error_after = curPos <= 1 ? "" : input_stream.GetImage();
  1026. if (curChar == '\n' || curChar == '\r') {
  1027. error_line++;
  1028. error_column = 0;
  1029. }
  1030. else
  1031. error_column++;
  1032. }
  1033. if (!EOFSeen) {
  1034. input_stream.backup(1);
  1035. error_after = curPos <= 1 ? "" : input_stream.GetImage();
  1036. }
  1037. throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  1038. }
  1039. }
  1040. }