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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 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;
  163. MatchLoop: 
  164. do 
  165. {
  166. switch (jjstateSet[--i])
  167. {
  169. case 0: 
  170. if ((0x7bffd0f8ffffd9ffL & l) != (ulong) 0L)
  171. {
  172. if (kind > 17)
  173. kind = 17;
  174. JjCheckNAddStates(0, 6);
  175. }
  176. else if ((0x100002600L & l) != (ulong) 0L)
  177. {
  178. if (kind > 6)
  179. kind = 6;
  180. }
  181. else if (curChar == 34)
  182. JjCheckNAdd(15);
  183. else if (curChar == 33)
  184. {
  185. if (kind > 9)
  186. kind = 9;
  187. }
  188. if (curChar == 38)
  189. jjstateSet[jjnewStateCnt++] = 4;
  190. break;
  192. case 4: 
  193. if (curChar == 38 && kind > 7)
  194. kind = 7;
  195. break;
  197. case 5: 
  198. if (curChar == 38)
  199. jjstateSet[jjnewStateCnt++] = 4;
  200. break;
  202. case 13: 
  203. if (curChar == 33 && kind > 9)
  204. kind = 9;
  205. break;
  207. case 14: 
  208. if (curChar == 34)
  209. JjCheckNAdd(15);
  210. break;
  212. case 15: 
  213. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  214. JjCheckNAddTwoStates(15, 16);
  215. break;
  217. case 16: 
  218. if (curChar == 34 && kind > 16)
  219. kind = 16;
  220. break;
  222. case 18: 
  223. if ((0x3ff000000000000L & l) == (ulong) 0L)
  224. break;
  225. if (kind > 18)
  226. kind = 18;
  227. JjAddStates(7, 8);
  228. break;
  230. case 19: 
  231. if (curChar == 46)
  232. JjCheckNAdd(20);
  233. break;
  235. case 20: 
  236. if ((0x3ff000000000000L & l) == (ulong) 0L)
  237. break;
  238. if (kind > 18)
  239. kind = 18;
  240. JjCheckNAdd(20);
  241. break;
  243. case 21: 
  244. if ((0x7bffd0f8ffffd9ffL & l) == (ulong) 0L)
  245. break;
  246. if (kind > 17)
  247. kind = 17;
  248. JjCheckNAddStates(0, 6);
  249. break;
  251. case 22: 
  252. if ((0x7bfff8f8ffffd9ffL & l) == (ulong) 0L)
  253. break;
  254. if (kind > 17)
  255. kind = 17;
  256. JjCheckNAddTwoStates(22, 23);
  257. break;
  259. case 24: 
  260. if ((0x84002f0600000000L & l) == (ulong) 0L)
  261. break;
  262. if (kind > 17)
  263. kind = 17;
  264. JjCheckNAddTwoStates(22, 23);
  265. break;
  267. case 25: 
  268. if ((0x7bfff8f8ffffd9ffL & l) != (ulong) 0L)
  269. JjCheckNAddStates(9, 11);
  270. break;
  272. case 26: 
  273. if (curChar == 42 && kind > 19)
  274. kind = 19;
  275. break;
  277. case 28: 
  278. if ((0x84002f0600000000L & l) != (ulong) 0L)
  279. JjCheckNAddStates(9, 11);
  280. break;
  282. case 29: 
  283. if ((0xfbfffcf8ffffd9ffL & l) == (ulong) 0L)
  284. break;
  285. if (kind > 20)
  286. kind = 20;
  287. JjCheckNAddTwoStates(29, 30);
  288. break;
  290. case 31: 
  291. if ((0x84002f0600000000L & l) == (ulong) 0L)
  292. break;
  293. if (kind > 20)
  294. kind = 20;
  295. JjCheckNAddTwoStates(29, 30);
  296. break;
  298. default:  break;
  300. }
  301. }
  302. while (i != startsAt);
  303. }
  304. else if (curChar < 128)
  305. {
  306. ulong l = ((ulong) 1L) << (curChar & 63);
  307. MatchLoop1: 
  308. do 
  309. {
  310. switch (jjstateSet[--i])
  311. {
  313. case 0: 
  314. if ((0x97ffffff97ffffffL & l) != (ulong) 0L)
  315. {
  316. if (kind > 17)
  317. kind = 17;
  318. JjCheckNAddStates(0, 6);
  319. }
  320. else if (curChar == 126)
  321. {
  322. if (kind > 18)
  323. kind = 18;
  324. jjstateSet[jjnewStateCnt++] = 18;
  325. }
  326. if (curChar == 92)
  327. JjCheckNAddStates(12, 14);
  328. else if (curChar == 78)
  329. jjstateSet[jjnewStateCnt++] = 11;
  330. else if (curChar == 124)
  331. jjstateSet[jjnewStateCnt++] = 8;
  332. else if (curChar == 79)
  333. jjstateSet[jjnewStateCnt++] = 6;
  334. else if (curChar == 65)
  335. jjstateSet[jjnewStateCnt++] = 2;
  336. break;
  338. case 1: 
  339. if (curChar == 68 && kind > 7)
  340. kind = 7;
  341. break;
  343. case 2: 
  344. if (curChar == 78)
  345. jjstateSet[jjnewStateCnt++] = 1;
  346. break;
  348. case 3: 
  349. if (curChar == 65)
  350. jjstateSet[jjnewStateCnt++] = 2;
  351. break;
  353. case 6: 
  354. if (curChar == 82 && kind > 8)
  355. kind = 8;
  356. break;
  358. case 7: 
  359. if (curChar == 79)
  360. jjstateSet[jjnewStateCnt++] = 6;
  361. break;
  363. case 8: 
  364. if (curChar == 124 && kind > 8)
  365. kind = 8;
  366. break;
  368. case 9: 
  369. if (curChar == 124)
  370. jjstateSet[jjnewStateCnt++] = 8;
  371. break;
  373. case 10: 
  374. if (curChar == 84 && kind > 9)
  375. kind = 9;
  376. break;
  378. case 11: 
  379. if (curChar == 79)
  380. jjstateSet[jjnewStateCnt++] = 10;
  381. break;
  383. case 12: 
  384. if (curChar == 78)
  385. jjstateSet[jjnewStateCnt++] = 11;
  386. break;
  388. case 15: 
  389. JjAddStates(15, 16);
  390. break;
  392. case 17: 
  393. if (curChar != 126)
  394. break;
  395. if (kind > 18)
  396. kind = 18;
  397. jjstateSet[jjnewStateCnt++] = 18;
  398. break;
  400. case 21: 
  401. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  402. break;
  403. if (kind > 17)
  404. kind = 17;
  405. JjCheckNAddStates(0, 6);
  406. break;
  408. case 22: 
  409. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  410. break;
  411. if (kind > 17)
  412. kind = 17;
  413. JjCheckNAddTwoStates(22, 23);
  414. break;
  416. case 23: 
  417. if (curChar == 92)
  418. JjCheckNAddTwoStates(24, 24);
  419. break;
  421. case 24: 
  422. if ((0x6800000078000000L & l) == (ulong) 0L)
  423. break;
  424. if (kind > 17)
  425. kind = 17;
  426. JjCheckNAddTwoStates(22, 23);
  427. break;
  429. case 25: 
  430. if ((0x97ffffff97ffffffL & l) != (ulong) 0L)
  431. JjCheckNAddStates(9, 11);
  432. break;
  434. case 27: 
  435. if (curChar == 92)
  436. JjCheckNAddTwoStates(28, 28);
  437. break;
  439. case 28: 
  440. if ((0x6800000078000000L & l) != (ulong) 0L)
  441. JjCheckNAddStates(9, 11);
  442. break;
  444. case 29: 
  445. if ((0x97ffffff97ffffffL & l) == (ulong) 0L)
  446. break;
  447. if (kind > 20)
  448. kind = 20;
  449. JjCheckNAddTwoStates(29, 30);
  450. break;
  452. case 30: 
  453. if (curChar == 92)
  454. JjCheckNAddTwoStates(31, 31);
  455. break;
  457. case 31: 
  458. if ((0x6800000078000000L & l) == (ulong) 0L)
  459. break;
  460. if (kind > 20)
  461. kind = 20;
  462. JjCheckNAddTwoStates(29, 30);
  463. break;
  465. case 32: 
  466. if (curChar == 92)
  467. JjCheckNAddStates(12, 14);
  468. break;
  470. default:  break;
  472. }
  473. }
  474. while (i != startsAt);
  475. }
  476. else
  477. {
  478. int hiByte = (int) (curChar >> 8);
  479. int i1 = hiByte >> 6;
  480. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  481. int i2 = (curChar & 0xff) >> 6;
  482. ulong l2 = ((ulong) 1L) << (curChar & 63);
  483. MatchLoop1: 
  484. do 
  485. {
  486. switch (jjstateSet[--i])
  487. {
  489. case 0: 
  490. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  491. break;
  492. if (kind > 17)
  493. kind = 17;
  494. JjCheckNAddStates(0, 6);
  495. break;
  497. case 15: 
  498. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  499. JjAddStates(15, 16);
  500. break;
  502. case 22: 
  503. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  504. break;
  505. if (kind > 17)
  506. kind = 17;
  507. JjCheckNAddTwoStates(22, 23);
  508. break;
  510. case 25: 
  511. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  512. JjCheckNAddStates(9, 11);
  513. break;
  515. case 29: 
  516. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  517. break;
  518. if (kind > 20)
  519. kind = 20;
  520. JjCheckNAddTwoStates(29, 30);
  521. break;
  523. default:  break;
  525. }
  526. }
  527. while (i != startsAt);
  528. }
  529. if (kind != 0x7fffffff)
  530. {
  531. jjmatchedKind = kind;
  532. jjmatchedPos = curPos;
  533. kind = 0x7fffffff;
  534. }
  535. ++curPos;
  536. if ((i = jjnewStateCnt) == (startsAt = 33 - (jjnewStateCnt = startsAt)))
  537. return curPos;
  538. try
  539. {
  540. curChar = input_stream.ReadChar();
  541. }
  542. catch (System.IO.IOException e)
  543. {
  544. return curPos;
  545. }
  546. }
  547. }
  548. private int JjStopStringLiteralDfa_1(int pos, ulong active0)
  549. {
  550. switch (pos)
  551. {
  553. case 0: 
  554. if ((active0 & 0x10000000L) != 0L)
  555. {
  556. jjmatchedKind = 31;
  557. return 4;
  558. }
  559. return - 1;
  561. default: 
  562. return - 1;
  564. }
  565. }
  566. private int JjStartNfa_1(int pos, ulong active0)
  567. {
  568. return JjMoveNfa_1(JjStopStringLiteralDfa_1(pos, (ulong) active0), pos + 1);
  569. }
  570. private int JjStartNfaWithStates_1(int pos, int kind, int state)
  571. {
  572. jjmatchedKind = kind;
  573. jjmatchedPos = pos;
  574. try
  575. {
  576. curChar = input_stream.ReadChar();
  577. }
  578. catch (System.IO.IOException)
  579. {
  580. return pos + 1;
  581. }
  582. return JjMoveNfa_1(state, pos + 1);
  583. }
  584. private int JjMoveStringLiteralDfa0_1()
  585. {
  586. switch (curChar)
  587. {
  589. case (char) (84): 
  590. return JjMoveStringLiteralDfa1_1((ulong) 0x10000000L);
  592. case (char) (125): 
  593. return JjStopAtPos(0, 29);
  595. default: 
  596. return JjMoveNfa_1(0, 0);
  598. }
  599. }
  600. private int JjMoveStringLiteralDfa1_1(ulong active0)
  601. {
  602. try
  603. {
  604. curChar = input_stream.ReadChar();
  605. }
  606. catch (System.IO.IOException)
  607. {
  608. JjStopStringLiteralDfa_1(0, (ulong) active0);
  609. return 1;
  610. }
  611. switch (curChar)
  612. {
  614. case (char) (79): 
  615. if ((active0 & 0x10000000L) != 0L)
  616. return JjStartNfaWithStates_1(1, 28, 4);
  617. break;
  619. default: 
  620. break;
  622. }
  623. return JjStartNfa_1(0, (ulong) active0);
  624. }
  625. private int JjMoveNfa_1(int startState, int curPos)
  626. {
  627. int[] nextStates;
  628. int startsAt = 0;
  629. jjnewStateCnt = 5;
  630. int i = 1;
  631. jjstateSet[0] = startState;
  632. int j, kind = 0x7fffffff;
  633. for (; ; )
  634. {
  635. if (++jjround == 0x7fffffff)
  636. ReInitRounds();
  637. if (curChar < 64)
  638. {
  639. ulong l = ((ulong) 1L) << curChar;
  640. MatchLoop1: 
  641. do 
  642. {
  643. switch (jjstateSet[--i])
  644. {
  646. case 0: 
  647. if ((0xfffffffeffffffffL & l) != (ulong) 0L)
  648. {
  649. if (kind > 31)
  650. kind = 31;
  651. JjCheckNAdd(4);
  652. }
  653. if ((0x100002600L & l) != (ulong) 0L)
  654. {
  655. if (kind > 6)
  656. kind = 6;
  657. }
  658. else if (curChar == 34)
  659. JjCheckNAdd(2);
  660. break;
  662. case 1: 
  663. if (curChar == 34)
  664. JjCheckNAdd(2);
  665. break;
  667. case 2: 
  668. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  669. JjCheckNAddTwoStates(2, 3);
  670. break;
  672. case 3: 
  673. if (curChar == 34 && kind > 30)
  674. kind = 30;
  675. break;
  677. case 4: 
  678. if ((0xfffffffeffffffffL & l) == (ulong) 0L)
  679. break;
  680. if (kind > 31)
  681. kind = 31;
  682. JjCheckNAdd(4);
  683. break;
  685. default:  break;
  687. }
  688. }
  689. while (i != startsAt);
  690. }
  691. else if (curChar < 128)
  692. {
  693. ulong l = ((ulong) 1L) << (curChar & 63);
  694. MatchLoop1: 
  695. do 
  696. {
  697. switch (jjstateSet[--i])
  698. {
  700. case 0: 
  701. case 4: 
  702. if ((0xdfffffffffffffffL & l) == (ulong) 0L)
  703. break;
  704. if (kind > 31)
  705. kind = 31;
  706. JjCheckNAdd(4);
  707. break;
  709. case 2: 
  710. JjAddStates(17, 18);
  711. break;
  713. default:  break;
  715. }
  716. }
  717. while (i != startsAt);
  718. }
  719. else
  720. {
  721. int hiByte = (int) (curChar >> 8);
  722. int i1 = hiByte >> 6;
  723. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  724. int i2 = (curChar & 0xff) >> 6;
  725. ulong l2 = ((ulong) 1L) << (curChar & 63);
  726. MatchLoop1: 
  727. do 
  728. {
  729. switch (jjstateSet[--i])
  730. {
  732. case 0: 
  733. case 4: 
  734. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  735. break;
  736. if (kind > 31)
  737. kind = 31;
  738. JjCheckNAdd(4);
  739. break;
  741. case 2: 
  742. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  743. JjAddStates(17, 18);
  744. break;
  746. default:  break;
  748. }
  749. }
  750. while (i != startsAt);
  751. }
  752. if (kind != 0x7fffffff)
  753. {
  754. jjmatchedKind = kind;
  755. jjmatchedPos = curPos;
  756. kind = 0x7fffffff;
  757. }
  758. ++curPos;
  759. if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
  760. return curPos;
  761. try
  762. {
  763. curChar = input_stream.ReadChar();
  764. }
  765. catch (System.IO.IOException)
  766. {
  767. return curPos;
  768. }
  769. }
  770. }
  771. private int JjMoveStringLiteralDfa0_0()
  772. {
  773. return JjMoveNfa_0(0, 0);
  774. }
  775. private int JjMoveNfa_0(int startState, int curPos)
  776. {
  777. int[] nextStates;
  778. int startsAt = 0;
  779. jjnewStateCnt = 3;
  780. int i = 1;
  781. jjstateSet[0] = startState;
  782. int j, kind = 0x7fffffff;
  783. for (; ; )
  784. {
  785. if (++jjround == 0x7fffffff)
  786. ReInitRounds();
  787. if (curChar < 64)
  788. {
  789. ulong l = ((ulong) 1L) << curChar;
  790. MatchLoop1: 
  791. do 
  792. {
  793. switch (jjstateSet[--i])
  794. {
  796. case 0: 
  797. if ((0x3ff000000000000L & l) == (ulong) 0L)
  798. break;
  799. if (kind > 23)
  800. kind = 23;
  801. JjAddStates(19, 20);
  802. break;
  804. case 1: 
  805. if (curChar == 46)
  806. JjCheckNAdd(2);
  807. break;
  809. case 2: 
  810. if ((0x3ff000000000000L & l) == (ulong) 0L)
  811. break;
  812. if (kind > 23)
  813. kind = 23;
  814. JjCheckNAdd(2);
  815. break;
  817. default:  break;
  819. }
  820. }
  821. while (i != startsAt);
  822. }
  823. else if (curChar < 128)
  824. {
  825. ulong l = ((ulong) 1L) << (curChar & 63);
  826. MatchLoop1: 
  827. do 
  828. {
  829. switch (jjstateSet[--i])
  830. {
  832. default:  break;
  834. }
  835. }
  836. while (i != startsAt);
  837. }
  838. else
  839. {
  840. int hiByte = (int) (curChar >> 8);
  841. int i1 = hiByte >> 6;
  842. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  843. int i2 = (curChar & 0xff) >> 6;
  844. ulong l2 = ((ulong) 1L) << (curChar & 63);
  845. MatchLoop1: 
  846. do 
  847. {
  848. switch (jjstateSet[--i])
  849. {
  851. default:  break;
  853. }
  854. }
  855. while (i != startsAt);
  856. }
  857. if (kind != 0x7fffffff)
  858. {
  859. jjmatchedKind = kind;
  860. jjmatchedPos = curPos;
  861. kind = 0x7fffffff;
  862. }
  863. ++curPos;
  864. if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
  865. return curPos;
  866. try
  867. {
  868. curChar = input_stream.ReadChar();
  869. }
  870. catch (System.IO.IOException e)
  871. {
  872. return curPos;
  873. }
  874. }
  875. }
  876. private int JjStopStringLiteralDfa_2(int pos, ulong active0)
  877. {
  878. switch (pos)
  879. {
  881. case 0: 
  882. if ((active0 & 0x1000000L) != (ulong) 0L)
  883. {
  884. jjmatchedKind = 27;
  885. return 4;
  886. }
  887. return - 1;
  889. default: 
  890. return - 1;
  892. }
  893. }
  894. private int JjStartNfa_2(int pos, ulong active0)
  895. {
  896. return JjMoveNfa_2(JjStopStringLiteralDfa_2(pos, (ulong) active0), pos + 1);
  897. }
  898. private int JjStartNfaWithStates_2(int pos, int kind, int state)
  899. {
  900. jjmatchedKind = kind;
  901. jjmatchedPos = pos;
  902. try
  903. {
  904. curChar = input_stream.ReadChar();
  905. }
  906. catch (System.IO.IOException e)
  907. {
  908. return pos + 1;
  909. }
  910. return JjMoveNfa_2(state, pos + 1);
  911. }
  912. private int JjMoveStringLiteralDfa0_2()
  913. {
  914. switch (curChar)
  915. {
  917. case (char) (84): 
  918. return JjMoveStringLiteralDfa1_2((ulong) 0x1000000L);
  920. case (char) (93): 
  921. return JjStopAtPos(0, 25);
  923. default: 
  924. return JjMoveNfa_2(0, 0);
  926. }
  927. }
  928. private int JjMoveStringLiteralDfa1_2(ulong active0)
  929. {
  930. try
  931. {
  932. curChar = input_stream.ReadChar();
  933. }
  934. catch (System.IO.IOException e)
  935. {
  936. JjStopStringLiteralDfa_2(0, (ulong) active0);
  937. return 1;
  938. }
  939. switch (curChar)
  940. {
  942. case (char) (79): 
  943. if ((active0 & 0x1000000L) != (ulong) 0L)
  944. return JjStartNfaWithStates_2(1, 24, 4);
  945. break;
  947. default: 
  948. break;
  950. }
  951. return JjStartNfa_2(0, (ulong) active0);
  952. }
  953. private int JjMoveNfa_2(int startState, int curPos)
  954. {
  955. int[] nextStates;
  956. int startsAt = 0;
  957. jjnewStateCnt = 5;
  958. int i = 1;
  959. jjstateSet[0] = startState;
  960. int j, kind = 0x7fffffff;
  961. for (; ; )
  962. {
  963. if (++jjround == 0x7fffffff)
  964. ReInitRounds();
  965. if (curChar < 64)
  966. {
  967. ulong l = ((ulong) 1L) << curChar;
  968. MatchLoop1: 
  969. do 
  970. {
  971. switch (jjstateSet[--i])
  972. {
  974. case 0: 
  975. if ((0xfffffffeffffffffL & l) != (ulong) 0L)
  976. {
  977. if (kind > 27)
  978. kind = 27;
  979. JjCheckNAdd(4);
  980. }
  981. if ((0x100002600L & l) != (ulong) 0L)
  982. {
  983. if (kind > 6)
  984. kind = 6;
  985. }
  986. else if (curChar == 34)
  987. JjCheckNAdd(2);
  988. break;
  990. case 1: 
  991. if (curChar == 34)
  992. JjCheckNAdd(2);
  993. break;
  995. case 2: 
  996. if ((0xfffffffbffffffffL & l) != (ulong) 0L)
  997. JjCheckNAddTwoStates(2, 3);
  998. break;
  1000. case 3: 
  1001. if (curChar == 34 && kind > 26)
  1002. kind = 26;
  1003. break;
  1005. case 4: 
  1006. if ((0xfffffffeffffffffL & l) == (ulong) 0L)
  1007. break;
  1008. if (kind > 27)
  1009. kind = 27;
  1010. JjCheckNAdd(4);
  1011. break;
  1013. default:  break;
  1015. }
  1016. }
  1017. while (i != startsAt);
  1018. }
  1019. else if (curChar < 128)
  1020. {
  1021. ulong l = ((ulong) 1L) << (curChar & 63);
  1022. MatchLoop1: 
  1023. do 
  1024. {
  1025. switch (jjstateSet[--i])
  1026. {
  1028. case 0: 
  1029. case 4: 
  1030. if ((0xffffffffdfffffffL & l) == (ulong) 0L)
  1031. break;
  1032. if (kind > 27)
  1033. kind = 27;
  1034. JjCheckNAdd(4);
  1035. break;
  1037. case 2: 
  1038. JjAddStates(17, 18);
  1039. break;
  1041. default:  break;
  1043. }
  1044. }
  1045. while (i != startsAt);
  1046. }
  1047. else
  1048. {
  1049. int hiByte = (int) (curChar >> 8);
  1050. int i1 = hiByte >> 6;
  1051. ulong l1 = ((ulong) 1L) << (hiByte & 63);
  1052. int i2 = (curChar & 0xff) >> 6;
  1053. ulong l2 = ((ulong) 1L) << (curChar & 63);
  1054. MatchLoop1: 
  1055. do 
  1056. {
  1057. switch (jjstateSet[--i])
  1058. {
  1060. case 0: 
  1061. case 4: 
  1062. if (!JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  1063. break;
  1064. if (kind > 27)
  1065. kind = 27;
  1066. JjCheckNAdd(4);
  1067. break;
  1069. case 2: 
  1070. if (JjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))
  1071. JjAddStates(17, 18);
  1072. break;
  1074. default:  break;
  1076. }
  1077. }
  1078. while (i != startsAt);
  1079. }
  1080. if (kind != 0x7fffffff)
  1081. {
  1082. jjmatchedKind = kind;
  1083. jjmatchedPos = curPos;
  1084. kind = 0x7fffffff;
  1085. }
  1086. ++curPos;
  1087. if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
  1088. return curPos;
  1089. try
  1090. {
  1091. curChar = input_stream.ReadChar();
  1092. }
  1093. catch (System.IO.IOException e)
  1094. {
  1095. return curPos;
  1096. }
  1097. }
  1098. }
  1099. 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};
  1100. private static bool JjCanMove_0(int hiByte, int i1, int i2, ulong l1, ulong l2)
  1101. {
  1102. switch (hiByte)
  1103. {
  1105. case 0: 
  1106. return ((jjbitVec2[i2] & l2) != (ulong) 0L);
  1108. default: 
  1109. if ((jjbitVec0[i1] & l1) != (ulong) 0L)
  1110. return true;
  1111. return false;
  1113. }
  1114. }
  1115. 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};
  1116. public static readonly System.String[] lexStateNames = new System.String[]{"Boost", "RangeEx", "RangeIn", "DEFAULT"};
  1117. 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};
  1118. internal static readonly ulong[] jjtoToken = new ulong[]{0xffffff81L};
  1119. internal static readonly long[] jjtoSkip = new long[]{0x40L};
  1120. protected internal CharStream input_stream;
  1121. private uint[] jjrounds = new uint[33];
  1122. private int[] jjstateSet = new int[66];
  1123. protected internal char curChar;
  1124. public QueryParserTokenManager(CharStream stream)
  1125. {
  1126. InitBlock();
  1127. input_stream = stream;
  1128. }
  1129. public QueryParserTokenManager(CharStream stream, int lexState) : this(stream)
  1130. {
  1131. SwitchTo(lexState);
  1132. }
  1133. public virtual void  ReInit(CharStream stream)
  1134. {
  1135. jjmatchedPos = jjnewStateCnt = 0;
  1136. curLexState = defaultLexState;
  1137. input_stream = stream;
  1138. ReInitRounds();
  1139. }
  1140. private void  ReInitRounds()
  1141. {
  1142. int i;
  1143. jjround = 0x80000001;
  1144. for (i = 33; i-- > 0; )
  1145. jjrounds[i] = 0x80000000;
  1146. }
  1147. public virtual void  ReInit(CharStream stream, int lexState)
  1148. {
  1149. ReInit(stream);
  1150. SwitchTo(lexState);
  1151. }
  1152. public virtual void  SwitchTo(int lexState)
  1153. {
  1154. if (lexState >= 4 || lexState < 0)
  1155. throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
  1156. else
  1157. curLexState = lexState;
  1158. }
  1160. protected internal virtual Token JjFillToken()
  1161. {
  1162. Token t = Token.NewToken(jjmatchedKind);
  1163. t.kind = jjmatchedKind;
  1164. System.String im = jjstrLiteralImages[jjmatchedKind];
  1165. t.image = (im == null) ? input_stream.GetImage() : im;
  1166. t.beginLine = input_stream.GetBeginLine();
  1167. t.beginColumn = input_stream.GetBeginColumn();
  1168. t.endLine = input_stream.GetEndLine();
  1169. t.endColumn = input_stream.GetEndColumn();
  1170. return t;
  1171. }
  1173. internal int curLexState = 3;
  1174. internal int defaultLexState = 3;
  1175. internal int jjnewStateCnt;
  1176. internal uint jjround;
  1177. internal int jjmatchedPos;
  1178. internal int jjmatchedKind;
  1180. public virtual Token GetNextToken()
  1181. {
  1182. int kind;
  1183. Token specialToken = null;
  1184. Token matchedToken;
  1185. int curPos = 0;
  1187. for (; ; )
  1188. {
  1189. try
  1190. {
  1191. curChar = input_stream.BeginToken();
  1192. }
  1193. catch (System.IO.IOException e)
  1194. {
  1195. jjmatchedKind = 0;
  1196. matchedToken = JjFillToken();
  1197. return matchedToken;
  1198. }
  1200. switch (curLexState)
  1201. {
  1203. case 0: 
  1204. jjmatchedKind = 0x7fffffff;
  1205. jjmatchedPos = 0;
  1206. curPos = JjMoveStringLiteralDfa0_0();
  1207. break;
  1209. case 1: 
  1210. jjmatchedKind = 0x7fffffff;
  1211. jjmatchedPos = 0;
  1212. curPos = JjMoveStringLiteralDfa0_1();
  1213. break;
  1215. case 2: 
  1216. jjmatchedKind = 0x7fffffff;
  1217. jjmatchedPos = 0;
  1218. curPos = JjMoveStringLiteralDfa0_2();
  1219. break;
  1221. case 3: 
  1222. jjmatchedKind = 0x7fffffff;
  1223. jjmatchedPos = 0;
  1224. curPos = JjMoveStringLiteralDfa0_3();
  1225. break;
  1226. }
  1227. if (jjmatchedKind != 0x7fffffff)
  1228. {
  1229. if (jjmatchedPos + 1 < curPos)
  1230. input_stream.Backup(curPos - jjmatchedPos - 1);
  1231. if ((jjtoToken[jjmatchedKind >> 6] & ((ulong) (1L << (jjmatchedKind & 63)))) != (ulong) 0L)
  1232. {
  1233. matchedToken = JjFillToken();
  1234. if (jjnewLexState[jjmatchedKind] != - 1)
  1235. curLexState = jjnewLexState[jjmatchedKind];
  1236. return matchedToken;
  1237. }
  1238. else
  1239. {
  1240. if (jjnewLexState[jjmatchedKind] != - 1)
  1241. curLexState = jjnewLexState[jjmatchedKind];
  1242. goto EOFLoop;
  1243. }
  1244. }
  1245. int error_line = input_stream.GetEndLine();
  1246. int error_column = input_stream.GetEndColumn();
  1247. System.String error_after = null;
  1248. bool EOFSeen = false;
  1249. try
  1250. {
  1251. input_stream.ReadChar(); input_stream.Backup(1);
  1252. }
  1253. catch (System.IO.IOException e1)
  1254. {
  1255. EOFSeen = true;
  1256. error_after = curPos <= 1?"":input_stream.GetImage();
  1257. if (curChar == 'n' || curChar == 'r')
  1258. {
  1259. error_line++;
  1260. error_column = 0;
  1261. }
  1262. else
  1263. error_column++;
  1264. }
  1265. if (!EOFSeen)
  1266. {
  1267. input_stream.Backup(1);
  1268. error_after = curPos <= 1?"":input_stream.GetImage();
  1269. }
  1270. throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  1272. EOFLoop: ;
  1273. }
  1274. }
  1275. }
  1276. }