开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 搜索引擎 > 查看源码
QueryParserTokenManager.cs
资源名称：xunlong0.6.rar　[点击查看]
上传用户：zhangkuixh
上传日期：2013-09-30
资源大小：5473k
文件大小：29k
源码类别：

搜索引擎

开发平台：

C#

QueryParserTokenManager.cs：源码内容
  1. /*
  2.  * Copyright 2004 The Apache Software Foundation
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  17. /* Generated By:JavaCC: Do not edit this line. QueryParserTokenManager.java */
  19. using System;
  20. using Lucene.Net.Analysis;
  21. using Lucene.Net.Documents;
  22. using Term = Lucene.Net.Index.Term;
  23. using Lucene.Net.Search;
  24. using Searchable = Lucene.Net.Search.Searchable;
  25. using Parameter = Lucene.Net.Util.Parameter;
  27. namespace Lucene.Net.QueryParsers
  28. {
  30. public class QueryParserTokenManager : QueryParserConstants
  31. {
  32. private void  InitBlock()
  33. {
  34. System.IO.StreamWriter temp_writer;
  35. temp_writer = new System.IO.StreamWriter(System.Console.OpenStandardOutput(), System.Console.Out.Encoding);
  36. temp_writer.AutoFlush = true;
  37. debugStream = temp_writer;
  38. }
  39. public System.IO.StreamWriter debugStream;
  40. public virtual void  SetDebugStream(System.IO.StreamWriter ds)
  41. {
  42. debugStream = ds;
  43. }
  44. private int JjStopStringLiteralDfa_3(int pos, long active0)
  45. {
  46. switch (pos)
  47. {
  49. default: 
  50. return - 1;
  52. }
  53. }
  54. private int JjStartNfa_3(int pos, long active0)
  55. {
  56. return JjMoveNfa_3(JjStopStringLiteralDfa_3(pos, active0), pos + 1);
  57. }
  58. private int JjStopAtPos(int pos, int kind)
  59. {
  60. jjmatchedKind = kind;
  61. jjmatchedPos = pos;
  62. return pos + 1;
  63. }
  64. private int JjStartNfaWithStates_3(int pos, int kind, int state)
  65. {
  66. jjmatchedKind = kind;
  67. jjmatchedPos = pos;
  68. try
  69. {
  70. curChar = input_stream.ReadChar();
  71. }
  72. catch (System.IO.IOException)
  73. {
  74. return pos + 1;
  75. }
  76. return JjMoveNfa_3(state, pos + 1);
  77. }
  78. private int JjMoveStringLiteralDfa0_3()
  79. {
  80. switch (curChar)
  81. {
  83. case (char) (40): 
  84. return JjStopAtPos(0, 12);
  86. case (char) (41): 
  87. return JjStopAtPos(0, 13);
  89. case (char) (43): 
  90. return JjStopAtPos(0, 10);
  92. case (char) (45): 
  93. return JjStopAtPos(0, 11);
  95. case (char) (58): 
  96. return JjStopAtPos(0, 14);
  98. case (char) (91): 
  99. return JjStopAtPos(0, 21);
  101. case (char) (94): 
  102. return JjStopAtPos(0, 15);
  104. case (char) (123): 
  105. return JjStopAtPos(0, 22);
  107. default: 
  108. return JjMoveNfa_3(0, 0);
  110. }
  111. }
  112. private void  JjCheckNAdd(int state)
  113. {
  114. if (jjrounds[state] != jjround)
  115. {
  116. jjstateSet[jjnewStateCnt++] = state;
  117. jjrounds[state] = jjround;
  118. }
  119. }
  120. private void  JjAddStates(int start, int end)
  121. {
  122. do 
  123. {
  124. jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  125. }
  126. while (start++ != end);
  127. }
  128. private void  JjCheckNAddTwoStates(int state1, int state2)
  129. {
  130. JjCheckNAdd(state1);
  131. JjCheckNAdd(state2);
  132. }
  133. private void  JjCheckNAddStates(int start, int end)
  134. {
  135. do 
  136. {
  137. JjCheckNAdd(jjnextStates[start]);
  138. }
  139. while (start++ != end);
  140. }
  141. private void  JjCheckNAddStates(int start)
  142. {
  143. JjCheckNAdd(jjnextStates[start]);
  144. JjCheckNAdd(jjnextStates[start + 1]);
  145. }
  146. internal static readonly ulong[] jjbitVec0 = new ulong[]{0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL};
  147. internal static readonly ulong[] jjbitVec2 = new ulong[]{0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL};
  148. private int JjMoveNfa_3(int startState, int curPos)
  149. {
  150. int[] nextStates;
  151. int startsAt = 0;
  152. jjnewStateCnt = 33;
  153. int i = 1;
  154. jjstateSet[0] = startState;
  155. int j, kind = 0x7fffffff;
  156. for (; ; )
  157. {
  158. if (++jjround == 0x7fffffff)
  159. ReInitRounds();
  160. if (curChar < 64)
  161. {
  162. ulong l = ((ulong) 1L) << curChar;
  164. MatchLoop: 
  165. do 
  166. {
  167. switch (jjstateSet[--i])
  168. {
  170. case 0: 
  171. if ((0x7bffd0f8ffffd9ffL & l) != (ulong) 0L)
  172. {
  173. if (kind > 17)
  174. kind = 17;
  175. JjCheckNAddStates(0, 6);
  176. }
  177. else if ((0x100002600L & l) != (ulong) 0L)
  178. {
  179. if (kind > 6)
  180. kind = 6;
  181. }
  182. else if (curChar == 34)
  183. JjCheckNAdd(15);
  184. else if (curChar == 33)
  185. {
  186. if (kind > 9)
  187. kind = 9;
  188. }
  189. if (curChar == 38)
  190. jjstateSet[jjnewStateCnt++] = 4;
  191. break;
  193. case 4: 
  194. if (curChar == 38 && kind > 7)
  195. kind = 7;
  196. break;
  198. case 5: 
  199. if (curChar == 38)
  200. jjstateSet[jjnewStateCnt++] = 4;
  201. break;
  203. case 13: 
  204. if (curChar == 33 && kind > 9)
  205. kind = 9;
  206. break;
  208. case 14: 
  209. if (curChar == 34)
  210. JjCheckNAdd(15);
  211. break;
  213. case 15: 
  214. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  215. JjCheckNAddTwoStates(15, 16);
  216. break;
  218. case 16: 
  219. if (curChar == 34 && kind > 16)
  220. kind = 16;
  221. break;
  223. case 18: 
  224. if ((0x3ff000000000000L & l) == (ulong) 0L)
  225. break;
  226. if (kind > 18)
  227. kind = 18;
  228. JjAddStates(7, 8);
  229. break;
  231. case 19: 
  232. if (curChar == 46)
  233. JjCheckNAdd(20);
  234. break;
  236. case 20: 
  237. if ((0x3ff000000000000L & l) == (ulong) 0L)
  238. break;
  239. if (kind > 18)
  240. kind = 18;
  241. JjCheckNAdd(20);
  242. break;
  244. case 21: 
  245. if ((0x7bffd0f8ffffd9ffL & l) == (ulong) 0L)
  246. break;
  247. if (kind > 17)
  248. kind = 17;
  249. JjCheckNAddStates(0, 6);
  250. break;
  252. case 22: 
  253. if ((0x7bfff8f8ffffd9ffL & l) == (ulong) 0L)
  254. break;
  255. if (kind > 17)
  256. kind = 17;
  257. JjCheckNAddTwoStates(22, 23);
  258. break;
  260. case 24: 
  261. if ((0x84002f0600000000L & l) == (ulong) 0L)
  262. break;
  263. if (kind > 17)
  264. kind = 17;
  265. JjCheckNAddTwoStates(22, 23);
  266. break;
  268. case 25: 
  269. if ((0x7bfff8f8ffffd9ffL & l) != (ulong) 0L)
  270. JjCheckNAddStates(9, 11);
  271. break;
  273. case 26: 
  274. if (curChar == 42 && kind > 19)
  275. kind = 19;
  276. break;
  278. case 28: 
  279. if ((0x84002f0600000000L & l) != (ulong) 0L)
  280. JjCheckNAddStates(9, 11);
  281. break;
  283. case 29: 
  284. if ((0xfbfffcf8ffffd9ffL & l) == (ulong) 0L)
  285. break;
  286. if (kind > 20)
  287. kind = 20;
  288. JjCheckNAddTwoStates(29, 30);
  289. break;
  291. case 31: 
  292. if ((0x84002f0600000000L & l) == (ulong) 0L)
  293. break;
  294. if (kind > 20)
  295. kind = 20;
  296. JjCheckNAddTwoStates(29, 30);
  297. break;
  299. default:  break;
  301. }
  302. }
  303. while (i != startsAt);
  304. }
  305. else if (curChar < 128)
  306. {
  307. ulong l = ((ulong) 1L) << (curChar & 63);
  309. MatchLoop1: 
  310. do 
  311. {
  312. switch (jjstateSet[--i])
  313. {
  315. case 0: 
  316. if ((0x97ffffff97ffffffL & l) != (ulong) 0L)
  317. {
  318. if (kind > 17)
  319. kind = 17;
  320. JjCheckNAddStates(0, 6);
  321. }
  322. else if (curChar == 126)
  323. {
  324. if (kind > 18)
  325. kind = 18;
  326. jjstateSet[jjnewStateCnt++] = 18;
  327. }
  328. if (curChar == 92)
  329. JjCheckNAddStates(12, 14);
  330. else if (curChar == 78)
  331. jjstateSet[jjnewStateCnt++] = 11;
  332. else if (curChar == 124)
  333. jjstateSet[jjnewStateCnt++] = 8;
  334. else if (curChar == 79)
  335. jjstateSet[jjnewStateCnt++] = 6;
  336. else if (curChar == 65)
  337. jjstateSet[jjnewStateCnt++] = 2;
  338. break;
  340. case 1: 
  341. if (curChar == 68 && kind > 7)
  342. kind = 7;
  343. break;
  345. case 2: 
  346. if (curChar == 78)
  347. jjstateSet[jjnewStateCnt++] = 1;
  348. break;
  350. case 3: 
  351. if (curChar == 65)
  352. jjstateSet[jjnewStateCnt++] = 2;
  353. break;
  355. case 6: 
  356. if (curChar == 82 && kind > 8)
  357. kind = 8;
  358. break;
  360. case 7: 
  361. if (curChar == 79)
  362. jjstateSet[jjnewStateCnt++] = 6;
  363. break;
  365. case 8: 
  366. if (curChar == 124 && kind > 8)
  367. kind = 8;
  368. break;
  370. case 9: 
  371. if (curChar == 124)
  372. jjstateSet[jjnewStateCnt++] = 8;
  373. break;
  375. case 10: 
  376. if (curChar == 84 && kind > 9)
  377. kind = 9;
  378. break;
  380. case 11: 
  381. if (curChar == 79)
  382. jjstateSet[jjnewStateCnt++] = 10;
  383. break;
  385. case 12: 
  386. if (curChar == 78)
  387. jjstateSet[jjnewStateCnt++] = 11;
  388. break;
  390. case 15: 
  391. JjAddStates(15, 16);
  392. break;
  394. case 17: 
  395. if (curChar != 126)
  396. break;
  397. if (kind > 18)
  398. kind = 18;
  399. jjstateSet[jjnewStateCnt++] = 18;
  400. break;
  402. case 21: 
  403. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  404. break;
  405. if (kind > 17)
  406. kind = 17;
  407. JjCheckNAddStates(0, 6);
  408. break;
  410. case 22: 
  411. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  412. break;
  413. if (kind > 17)
  414. kind = 17;
  415. JjCheckNAddTwoStates(22, 23);
  416. break;
  418. case 23: 
  419. if (curChar == 92)
  420. JjCheckNAddTwoStates(24, 24);
  421. break;
  423. case 24: 
  424. if ((0x6800000078000000L & l) == (ulong) 0L)
  425. break;
  426. if (kind > 17)
  427. kind = 17;
  428. JjCheckNAddTwoStates(22, 23);
  429. break;
  431. case 25: 
  432. if ((0x97ffffff97ffffffL & l) != (ulong) 0L)
  433. JjCheckNAddStates(9, 11);
  434. break;
  436. case 27: 
  437. if (curChar == 92)
  438. JjCheckNAddTwoStates(28, 28);
  439. break;
  441. case 28: 
  442. if ((0x6800000078000000L & l) != (ulong) 0L)
  443. JjCheckNAddStates(9, 11);
  444. break;
  446. case 29: 
  447. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  448. break;
  449. if (kind > 20)
  450. kind = 20;
  451. JjCheckNAddTwoStates(29, 30);
  452. break;
  454. case 30: 
  455. if (curChar == 92)
  456. JjCheckNAddTwoStates(31, 31);
  457. break;
  459. case 31: 
  460. if ((0x6800000078000000L & l) == (ulong) 0L)
  461. break;
  462. if (kind > 20)
  463. kind = 20;
  464. JjCheckNAddTwoStates(29, 30);
  465. break;
  467. case 32: 
  468. if (curChar == 92)
  469. JjCheckNAddStates(12, 14);
  470. break;
  472. default:  break;
  474. }
  475. }
  476. while (i != startsAt);
  477. }
  478. else
  479. {
  480. int hiByte = (int) (curChar >> 8);
  481. int i1 = hiByte >> 6;
  482. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  483. int i2 = (curChar & 0xff) >> 6;
  484. ulong l2 = ((ulong) 1L) << (curChar & 63);
  486. MatchLoop1: 
  487. do 
  488. {
  489. switch (jjstateSet[--i])
  490. {
  492. case 0: 
  493. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  494. break;
  495. if (kind > 17)
  496. kind = 17;
  497. JjCheckNAddStates(0, 6);
  498. break;
  500. case 15: 
  501. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  502. JjAddStates(15, 16);
  503. break;
  505. case 22: 
  506. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  507. break;
  508. if (kind > 17)
  509. kind = 17;
  510. JjCheckNAddTwoStates(22, 23);
  511. break;
  513. case 25: 
  514. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  515. JjCheckNAddStates(9, 11);
  516. break;
  518. case 29: 
  519. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  520. break;
  521. if (kind > 20)
  522. kind = 20;
  523. JjCheckNAddTwoStates(29, 30);
  524. break;
  526. default:  break;
  528. }
  529. }
  530. while (i != startsAt);
  531. }
  532. if (kind != 0x7fffffff)
  533. {
  534. jjmatchedKind = kind;
  535. jjmatchedPos = curPos;
  536. kind = 0x7fffffff;
  537. }
  538. ++curPos;
  539. if ((i = jjnewStateCnt) == (startsAt = 33 - (jjnewStateCnt = startsAt)))
  540. return curPos;
  541. try
  542. {
  543. curChar = input_stream.ReadChar();
  544. }
  545. catch (System.IO.IOException e)
  546. {
  547. return curPos;
  548. }
  549. }
  550. }
  551. private int JjStopStringLiteralDfa_1(int pos, ulong active0)
  552. {
  553. switch (pos)
  554. {
  556. case 0: 
  557. if ((active0 & 0x10000000L) != 0L)
  558. {
  559. jjmatchedKind = 31;
  560. return 4;
  561. }
  562. return - 1;
  564. default: 
  565. return - 1;
  567. }
  568. }
  569. private int JjStartNfa_1(int pos, ulong active0)
  570. {
  571. return JjMoveNfa_1(JjStopStringLiteralDfa_1(pos, (ulong) active0), pos + 1);
  572. }
  573. private int JjStartNfaWithStates_1(int pos, int kind, int state)
  574. {
  575. jjmatchedKind = kind;
  576. jjmatchedPos = pos;
  577. try
  578. {
  579. curChar = input_stream.ReadChar();
  580. }
  581. catch (System.IO.IOException)
  582. {
  583. return pos + 1;
  584. }
  585. return JjMoveNfa_1(state, pos + 1);
  586. }
  587. private int JjMoveStringLiteralDfa0_1()
  588. {
  589. switch (curChar)
  590. {
  592. case (char) (84): 
  593. return JjMoveStringLiteralDfa1_1((ulong) 0x10000000L);
  595. case (char) (125): 
  596. return JjStopAtPos(0, 29);
  598. default: 
  599. return JjMoveNfa_1(0, 0);
  601. }
  602. }
  603. private int JjMoveStringLiteralDfa1_1(ulong active0)
  604. {
  605. try
  606. {
  607. curChar = input_stream.ReadChar();
  608. }
  609. catch (System.IO.IOException)
  610. {
  611. JjStopStringLiteralDfa_1(0, (ulong) active0);
  612. return 1;
  613. }
  614. switch (curChar)
  615. {
  617. case (char) (79): 
  618. if ((active0 & 0x10000000L) != 0L)
  619. return JjStartNfaWithStates_1(1, 28, 4);
  620. break;
  622. default: 
  623. break;
  625. }
  626. return JjStartNfa_1(0, (ulong) active0);
  627. }
  628. private int JjMoveNfa_1(int startState, int curPos)
  629. {
  630. int[] nextStates;
  631. int startsAt = 0;
  632. jjnewStateCnt = 5;
  633. int i = 1;
  634. jjstateSet[0] = startState;
  635. int j, kind = 0x7fffffff;
  636. for (; ; )
  637. {
  638. if (++jjround == 0x7fffffff)
  639. ReInitRounds();
  640. if (curChar < 64)
  641. {
  642. ulong l = ((ulong) 1L) << curChar;
  644. MatchLoop1: 
  645. do 
  646. {
  647. switch (jjstateSet[--i])
  648. {
  650. case 0: 
  651. if ((0xfffffffeffffffffL & l) != (ulong) 0L)
  652. {
  653. if (kind > 31)
  654. kind = 31;
  655. JjCheckNAdd(4);
  656. }
  657. if ((0x100002600L & l) != (ulong) 0L)
  658. {
  659. if (kind > 6)
  660. kind = 6;
  661. }
  662. else if (curChar == 34)
  663. JjCheckNAdd(2);
  664. break;
  666. case 1: 
  667. if (curChar == 34)
  668. JjCheckNAdd(2);
  669. break;
  671. case 2: 
  672. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  673. JjCheckNAddTwoStates(2, 3);
  674. break;
  676. case 3: 
  677. if (curChar == 34 && kind > 30)
  678. kind = 30;
  679. break;
  681. case 4: 
  682. if ((0xfffffffeffffffffL & l) == (ulong) 0L)
  683. break;
  684. if (kind > 31)
  685. kind = 31;
  686. JjCheckNAdd(4);
  687. break;
  689. default:  break;
  691. }
  692. }
  693. while (i != startsAt);
  694. }
  695. else if (curChar < 128)
  696. {
  697. ulong l = ((ulong) 1L) << (curChar & 63);
  699. MatchLoop1: 
  700. do 
  701. {
  702. switch (jjstateSet[--i])
  703. {
  705. case 0: 
  706. case 4: 
  707. if ((0xdfffffffffffffffL & l) == (ulong) 0L)
  708. break;
  709. if (kind > 31)
  710. kind = 31;
  711. JjCheckNAdd(4);
  712. break;
  714. case 2: 
  715. JjAddStates(17, 18);
  716. break;
  718. default:  break;
  720. }
  721. }
  722. while (i != startsAt);
  723. }
  724. else
  725. {
  726. int hiByte = (int) (curChar >> 8);
  727. int i1 = hiByte >> 6;
  728. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  729. int i2 = (curChar & 0xff) >> 6;
  730. ulong l2 = ((ulong) 1L) << (curChar & 63);
  732. MatchLoop1: 
  733. do 
  734. {
  735. switch (jjstateSet[--i])
  736. {
  738. case 0: 
  739. case 4: 
  740. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  741. break;
  742. if (kind > 31)
  743. kind = 31;
  744. JjCheckNAdd(4);
  745. break;
  747. case 2: 
  748. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  749. JjAddStates(17, 18);
  750. break;
  752. default:  break;
  754. }
  755. }
  756. while (i != startsAt);
  757. }
  758. if (kind != 0x7fffffff)
  759. {
  760. jjmatchedKind = kind;
  761. jjmatchedPos = curPos;
  762. kind = 0x7fffffff;
  763. }
  764. ++curPos;
  765. if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
  766. return curPos;
  767. try
  768. {
  769. curChar = input_stream.ReadChar();
  770. }
  771. catch (System.IO.IOException)
  772. {
  773. return curPos;
  774. }
  775. }
  776. }
  777. private int JjMoveStringLiteralDfa0_0()
  778. {
  779. return JjMoveNfa_0(0, 0);
  780. }
  781. private int JjMoveNfa_0(int startState, int curPos)
  782. {
  783. int[] nextStates;
  784. int startsAt = 0;
  785. jjnewStateCnt = 3;
  786. int i = 1;
  787. jjstateSet[0] = startState;
  788. int j, kind = 0x7fffffff;
  789. for (; ; )
  790. {
  791. if (++jjround == 0x7fffffff)
  792. ReInitRounds();
  793. if (curChar < 64)
  794. {
  795. ulong l = ((ulong) 1L) << curChar;
  797. MatchLoop1: 
  798. do 
  799. {
  800. switch (jjstateSet[--i])
  801. {
  803. case 0: 
  804. if ((0x3ff000000000000L & l) == (ulong) 0L)
  805. break;
  806. if (kind > 23)
  807. kind = 23;
  808. JjAddStates(19, 20);
  809. break;
  811. case 1: 
  812. if (curChar == 46)
  813. JjCheckNAdd(2);
  814. break;
  816. case 2: 
  817. if ((0x3ff000000000000L & l) == (ulong) 0L)
  818. break;
  819. if (kind > 23)
  820. kind = 23;
  821. JjCheckNAdd(2);
  822. break;
  824. default:  break;
  826. }
  827. }
  828. while (i != startsAt);
  829. }
  830. else if (curChar < 128)
  831. {
  832. ulong l = ((ulong) 1L) << (curChar & 63);
  834. MatchLoop1: 
  835. do 
  836. {
  837. switch (jjstateSet[--i])
  838. {
  840. default:  break;
  842. }
  843. }
  844. while (i != startsAt);
  845. }
  846. else
  847. {
  848. int hiByte = (int) (curChar >> 8);
  849. int i1 = hiByte >> 6;
  850. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  851. int i2 = (curChar & 0xff) >> 6;
  852. ulong l2 = ((ulong) 1L) << (curChar & 63);
  854. MatchLoop1: 
  855. do 
  856. {
  857. switch (jjstateSet[--i])
  858. {
  860. default:  break;
  862. }
  863. }
  864. while (i != startsAt);
  865. }
  866. if (kind != 0x7fffffff)
  867. {
  868. jjmatchedKind = kind;
  869. jjmatchedPos = curPos;
  870. kind = 0x7fffffff;
  871. }
  872. ++curPos;
  873. if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
  874. return curPos;
  875. try
  876. {
  877. curChar = input_stream.ReadChar();
  878. }
  879. catch (System.IO.IOException e)
  880. {
  881. return curPos;
  882. }
  883. }
  884. }
  885. private int JjStopStringLiteralDfa_2(int pos, ulong active0)
  886. {
  887. switch (pos)
  888. {
  890. case 0: 
  891. if ((active0 & 0x1000000L) != (ulong) 0L)
  892. {
  893. jjmatchedKind = 27;
  894. return 4;
  895. }
  896. return - 1;
  898. default: 
  899. return - 1;
  901. }
  902. }
  903. private int JjStartNfa_2(int pos, ulong active0)
  904. {
  905. return JjMoveNfa_2(JjStopStringLiteralDfa_2(pos, (ulong) active0), pos + 1);
  906. }
  907. private int JjStartNfaWithStates_2(int pos, int kind, int state)
  908. {
  909. jjmatchedKind = kind;
  910. jjmatchedPos = pos;
  911. try
  912. {
  913. curChar = input_stream.ReadChar();
  914. }
  915. catch (System.IO.IOException e)
  916. {
  917. return pos + 1;
  918. }
  919. return JjMoveNfa_2(state, pos + 1);
  920. }
  921. private int JjMoveStringLiteralDfa0_2()
  922. {
  923. switch (curChar)
  924. {
  926. case (char) (84): 
  927. return JjMoveStringLiteralDfa1_2((ulong) 0x1000000L);
  929. case (char) (93): 
  930. return JjStopAtPos(0, 25);
  932. default: 
  933. return JjMoveNfa_2(0, 0);
  935. }
  936. }
  937. private int JjMoveStringLiteralDfa1_2(ulong active0)
  938. {
  939. try
  940. {
  941. curChar = input_stream.ReadChar();
  942. }
  943. catch (System.IO.IOException e)
  944. {
  945. JjStopStringLiteralDfa_2(0, (ulong) active0);
  946. return 1;
  947. }
  948. switch (curChar)
  949. {
  951. case (char) (79): 
  952. if ((active0 & 0x1000000L) != (ulong) 0L)
  953. return JjStartNfaWithStates_2(1, 24, 4);
  954. break;
  956. default: 
  957. break;
  959. }
  960. return JjStartNfa_2(0, (ulong) active0);
  961. }
  962. private int JjMoveNfa_2(int startState, int curPos)
  963. {
  964. int[] nextStates;
  965. int startsAt = 0;
  966. jjnewStateCnt = 5;
  967. int i = 1;
  968. jjstateSet[0] = startState;
  969. int j, kind = 0x7fffffff;
  970. for (; ; )
  971. {
  972. if (++jjround == 0x7fffffff)
  973. ReInitRounds();
  974. if (curChar < 64)
  975. {
  976. ulong l = ((ulong) 1L) << curChar;
  978. MatchLoop1: 
  979. do 
  980. {
  981. switch (jjstateSet[--i])
  982. {
  984. case 0: 
  985. if ((0xfffffffeffffffffL & l) != (ulong) 0L)
  986. {
  987. if (kind > 27)
  988. kind = 27;
  989. JjCheckNAdd(4);
  990. }
  991. if ((0x100002600L & l) != (ulong) 0L)
  992. {
  993. if (kind > 6)
  994. kind = 6;
  995. }
  996. else if (curChar == 34)
  997. JjCheckNAdd(2);
  998. break;
  1000. case 1: 
  1001. if (curChar == 34)
  1002. JjCheckNAdd(2);
  1003. break;
  1005. case 2: 
  1006. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  1007. JjCheckNAddTwoStates(2, 3);
  1008. break;
  1010. case 3: 
  1011. if (curChar == 34 && kind > 26)
  1012. kind = 26;
  1013. break;
  1015. case 4: 
  1016. if ((0xfffffffeffffffffL & l) == (ulong) 0L)
  1017. break;
  1018. if (kind > 27)
  1019. kind = 27;
  1020. JjCheckNAdd(4);
  1021. break;
  1023. default:  break;
  1025. }
  1026. }
  1027. while (i != startsAt);
  1028. }
  1029. else if (curChar < 128)
  1030. {
  1031. ulong l = ((ulong) 1L) << (curChar & 63);
  1033. MatchLoop1: 
  1034. do 
  1035. {
  1036. switch (jjstateSet[--i])
  1037. {
  1039. case 0: 
  1040. case 4: 
  1041. if ((0xffffffffdfffffffL & l) == (ulong) 0L)
  1042. break;
  1043. if (kind > 27)
  1044. kind = 27;
  1045. JjCheckNAdd(4);
  1046. break;
  1048. case 2: 
  1049. JjAddStates(17, 18);
  1050. break;
  1052. default:  break;
  1054. }
  1055. }
  1056. while (i != startsAt);
  1057. }
  1058. else
  1059. {
  1060. int hiByte = (int) (curChar >> 8);
  1061. int i1 = hiByte >> 6;
  1062. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  1063. int i2 = (curChar & 0xff) >> 6;
  1064. ulong l2 = ((ulong) 1L) << (curChar & 63);
  1066. MatchLoop1: 
  1067. do 
  1068. {
  1069. switch (jjstateSet[--i])
  1070. {
  1072. case 0: 
  1073. case 4: 
  1074. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  1075. break;
  1076. if (kind > 27)
  1077. kind = 27;
  1078. JjCheckNAdd(4);
  1079. break;
  1081. case 2: 
  1082. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  1083. JjAddStates(17, 18);
  1084. break;
  1086. default:  break;
  1088. }
  1089. }
  1090. while (i != startsAt);
  1091. }
  1092. if (kind != 0x7fffffff)
  1093. {
  1094. jjmatchedKind = kind;
  1095. jjmatchedPos = curPos;
  1096. kind = 0x7fffffff;
  1097. }
  1098. ++curPos;
  1099. if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
  1100. return curPos;
  1101. try
  1102. {
  1103. curChar = input_stream.ReadChar();
  1104. }
  1105. catch (System.IO.IOException e)
  1106. {
  1107. return curPos;
  1108. }
  1109. }
  1110. }
  1111. internal static readonly int[] jjnextStates = new int[]{22, 25, 26, 29, 30, 27, 23, 18, 19, 25, 26, 27, 24, 28, 31, 15, 16, 2, 3, 0, 1};
  1112. private static bool JjCanMove_0(int hiByte, int i1, int i2, ulong l1, ulong l2)
  1113. {
  1114. switch (hiByte)
  1115. {
  1117. case 0: 
  1118. return ((jjbitVec2[i2] & l2) != (ulong) 0L);
  1120. default: 
  1121. if ((jjbitVec0[i1] & l1) != (ulong) 0L)
  1122. return true;
  1123. return false;
  1125. }
  1126. }
  1127. public static readonly System.String[] jjstrLiteralImages = new System.String[]{"", null, null, null, null, null, null, null, null, null, "x002B", "x002D", "x0028", "x0029", "x003A", "x005E", null, null, null, null, null, "x005B", "x007B", null, "x0054x004F", "x005D", null, null, "x0054x004F", "x007D", null, null};
  1128. public static readonly System.String[] lexStateNames = new System.String[]{"Boost", "RangeEx", "RangeIn", "DEFAULT"};
  1129. public static readonly int[] jjnewLexState = new int[]{- 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, 0, - 1, - 1, - 1, - 1, - 1, 2, 1, 3, - 1, 3, - 1, - 1, - 1, 3, - 1, - 1};
  1130. internal static readonly ulong[] jjtoToken = new ulong[]{0xffffff81L};
  1131. internal static readonly long[] jjtoSkip = new long[]{0x40L};
  1132. protected internal CharStream input_stream;
  1133. private uint[] jjrounds = new uint[33];
  1134. private int[] jjstateSet = new int[66];
  1135. protected internal char curChar;
  1136. public QueryParserTokenManager(CharStream stream)
  1137. {
  1138. InitBlock();
  1139. input_stream = stream;
  1140. }
  1141. public QueryParserTokenManager(CharStream stream, int lexState) : this(stream)
  1142. {
  1143. SwitchTo(lexState);
  1144. }
  1145. public virtual void  ReInit(CharStream stream)
  1146. {
  1147. jjmatchedPos = jjnewStateCnt = 0;
  1148. curLexState = defaultLexState;
  1149. input_stream = stream;
  1150. ReInitRounds();
  1151. }
  1152. private void  ReInitRounds()
  1153. {
  1154. int i;
  1155. jjround = 0x80000001;
  1156. for (i = 33; i-- > 0; )
  1157. jjrounds[i] = 0x80000000;
  1158. }
  1159. public virtual void  ReInit(CharStream stream, int lexState)
  1160. {
  1161. ReInit(stream);
  1162. SwitchTo(lexState);
  1163. }
  1164. public virtual void  SwitchTo(int lexState)
  1165. {
  1166. if (lexState >= 4 || lexState < 0)
  1167. throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
  1168. else
  1169. curLexState = lexState;
  1170. }
  1172. protected internal virtual Token JjFillToken()
  1173. {
  1174. Token t = Token.NewToken(jjmatchedKind);
  1175. t.kind = jjmatchedKind;
  1176. System.String im = jjstrLiteralImages[jjmatchedKind];
  1177. t.image = (im == null) ? input_stream.GetImage() : im;
  1178. t.beginLine = input_stream.GetBeginLine();
  1179. t.beginColumn = input_stream.GetBeginColumn();
  1180. t.endLine = input_stream.GetEndLine();
  1181. t.endColumn = input_stream.GetEndColumn();
  1182. return t;
  1183. }
  1185. internal int curLexState = 3;
  1186. internal int defaultLexState = 3;
  1187. internal int jjnewStateCnt;
  1188. internal uint jjround;
  1189. internal int jjmatchedPos;
  1190. internal int jjmatchedKind;
  1192. public virtual Token GetNextToken()
  1193. {
  1194. int kind;
  1195. Token specialToken = null;
  1196. Token matchedToken;
  1197. int curPos = 0;
  1199. for (; ; )
  1200. {
  1201. try
  1202. {
  1203. curChar = input_stream.BeginToken();
  1204. }
  1205. catch (System.IO.IOException e)
  1206. {
  1207. jjmatchedKind = 0;
  1208. matchedToken = JjFillToken();
  1209. return matchedToken;
  1210. }
  1212. switch (curLexState)
  1213. {
  1215. case 0: 
  1216. jjmatchedKind = 0x7fffffff;
  1217. jjmatchedPos = 0;
  1218. curPos = JjMoveStringLiteralDfa0_0();
  1219. break;
  1221. case 1: 
  1222. jjmatchedKind = 0x7fffffff;
  1223. jjmatchedPos = 0;
  1224. curPos = JjMoveStringLiteralDfa0_1();
  1225. break;
  1227. case 2: 
  1228. jjmatchedKind = 0x7fffffff;
  1229. jjmatchedPos = 0;
  1230. curPos = JjMoveStringLiteralDfa0_2();
  1231. break;
  1233. case 3: 
  1234. jjmatchedKind = 0x7fffffff;
  1235. jjmatchedPos = 0;
  1236. curPos = JjMoveStringLiteralDfa0_3();
  1237. break;
  1238. }
  1239. if (jjmatchedKind != 0x7fffffff)
  1240. {
  1241. if (jjmatchedPos + 1 < curPos)
  1242. input_stream.Backup(curPos - jjmatchedPos - 1);
  1243. if ((jjtoToken[jjmatchedKind >> 6] & ((ulong) (1L << (jjmatchedKind & 63)))) != (ulong) 0L)
  1244. {
  1245. matchedToken = JjFillToken();
  1246. if (jjnewLexState[jjmatchedKind] != - 1)
  1247. curLexState = jjnewLexState[jjmatchedKind];
  1248. return matchedToken;
  1249. }
  1250. else
  1251. {
  1252. if (jjnewLexState[jjmatchedKind] != - 1)
  1253. curLexState = jjnewLexState[jjmatchedKind];
  1254. goto EOFLoop;
  1255. }
  1256. }
  1257. int error_line = input_stream.GetEndLine();
  1258. int error_column = input_stream.GetEndColumn();
  1259. System.String error_after = null;
  1260. bool EOFSeen = false;
  1261. try
  1262. {
  1263. input_stream.ReadChar(); input_stream.Backup(1);
  1264. }
  1265. catch (System.IO.IOException e1)
  1266. {
  1267. EOFSeen = true;
  1268. error_after = curPos <= 1?"":input_stream.GetImage();
  1269. if (curChar == 'n' || curChar == 'r')
  1270. {
  1271. error_line++;
  1272. error_column = 0;
  1273. }
  1274. else
  1275. error_column++;
  1276. }
  1277. if (!EOFSeen)
  1278. {
  1279. input_stream.Backup(1);
  1280. error_after = curPos <= 1?"":input_stream.GetImage();
  1281. }
  1282. throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  1284. EOFLoop: ;
  1285. }
  1286. }
  1287. }
  1288. }