Lucene.Net/QueryParser/QueryParserTokenManager.cs

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