mcs/tools/monodoc/Lucene.Net/Demo/DemoLib/HTML/HTMLParserTokenManager.cs

   1 /* \r
   2  * Copyright 2004 The Apache Software Foundation\r
   3  * \r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  * \r
   8  * http://www.apache.org/licenses/LICENSE-2.0\r
   9  * \r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 using System;\r
  18 namespace Lucene.Net.Demo.Html\r
  19 {\r
  20         \r
  21     public class HTMLParserTokenManager : HTMLParserConstants\r
  22     {\r
  23         private void  InitBlock()\r
  24         {\r
  25             System.IO.StreamWriter temp_writer;\r
  26             temp_writer = new System.IO.StreamWriter(System.Console.OpenStandardOutput(), System.Console.Out.Encoding);\r
  27             temp_writer.AutoFlush = true;\r
  28             debugStream = temp_writer;\r
  29         }\r
  30         public System.IO.StreamWriter debugStream;\r
  31         public virtual void  SetDebugStream(System.IO.StreamWriter ds)\r
  32         {\r
  33             debugStream = ds;\r
  34         }\r
  35         private int jjStopStringLiteralDfa_0(int pos, long active0)\r
  36         {\r
  37             switch (pos)\r
  38             {\r
  39                                 \r
  40                 case 0: \r
  41                     if ((active0 & 0x32L) != 0L)\r
  42                         return 17;\r
  43                     return - 1;\r
  44                                 \r
  45                 case 1: \r
  46                     if ((active0 & 0x30L) != 0L)\r
  47                         return 22;\r
  48                     if ((active0 & 0x2L) != 0L)\r
  49                     {\r
  50                         if (jjmatchedPos != 1)\r
  51                         {\r
  52                             jjmatchedKind = 2;\r
  53                             jjmatchedPos = 1;\r
  54                         }\r
  55                         return 19;\r
  56                     }\r
  57                     return - 1;\r
  58                                 \r
  59                 case 2: \r
  60                     if ((active0 & 0x2L) != 0L)\r
  61                     {\r
  62                         jjmatchedKind = 2;\r
  63                         jjmatchedPos = 2;\r
  64                         return 20;\r
  65                     }\r
  66                     return - 1;\r
  67                                 \r
  68                 case 3: \r
  69                     if ((active0 & 0x2L) != 0L)\r
  70                     {\r
  71                         jjmatchedKind = 2;\r
  72                         jjmatchedPos = 3;\r
  73                         return 20;\r
  74                     }\r
  75                     return - 1;\r
  76                                 \r
  77                 case 4: \r
  78                     if ((active0 & 0x2L) != 0L)\r
  79                     {\r
  80                         jjmatchedKind = 2;\r
  81                         jjmatchedPos = 4;\r
  82                         return 20;\r
  83                     }\r
  84                     return - 1;\r
  85                                 \r
  86                 case 5: \r
  87                     if ((active0 & 0x2L) != 0L)\r
  88                     {\r
  89                         jjmatchedKind = 2;\r
  90                         jjmatchedPos = 5;\r
  91                         return 20;\r
  92                     }\r
  93                     return - 1;\r
  94                                 \r
  95                 default: \r
  96                     return - 1;\r
  97                                 \r
  98             }\r
  99         }\r
 100         private int jjStartNfa_0(int pos, long active0)\r
 101         {\r
 102             return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);\r
 103         }\r
 104         private int jjStopAtPos(int pos, int kind)\r
 105         {\r
 106             jjmatchedKind = kind;\r
 107             jjmatchedPos = pos;\r
 108             return pos + 1;\r
 109         }\r
 110         private int jjStartNfaWithStates_0(int pos, int kind, int state)\r
 111         {\r
 112             jjmatchedKind = kind;\r
 113             jjmatchedPos = pos;\r
 114             try\r
 115             {\r
 116                 curChar = input_stream.ReadChar();\r
 117             }\r
 118             catch (System.IO.IOException e)\r
 119             {\r
 120                 return pos + 1;\r
 121             }\r
 122             return jjMoveNfa_0(state, pos + 1);\r
 123         }\r
 124         private int jjMoveStringLiteralDfa0_0()\r
 125         {\r
 126             switch (curChar)\r
 127             {\r
 128                                 \r
 129                 case (char) (60): \r
 130                     return jjMoveStringLiteralDfa1_0(0x32L);\r
 131                                 \r
 132                 default: \r
 133                     return jjMoveNfa_0(11, 0);\r
 134                                 \r
 135             }\r
 136         }\r
 137         private int jjMoveStringLiteralDfa1_0(long active0)\r
 138         {\r
 139             try\r
 140             {\r
 141                 curChar = input_stream.ReadChar();\r
 142             }\r
 143             catch (System.IO.IOException e)\r
 144             {\r
 145                 jjStopStringLiteralDfa_0(0, active0);\r
 146                 return 1;\r
 147             }\r
 148             switch (curChar)\r
 149             {\r
 150                                 \r
 151                 case (char) (33): \r
 152                     if ((active0 & 0x20L) != 0L)\r
 153                     {\r
 154                         jjmatchedKind = 5;\r
 155                         jjmatchedPos = 1;\r
 156                     }\r
 157                     return jjMoveStringLiteralDfa2_0(active0, 0x10L);\r
 158                                 \r
 159                 case (char) (115): \r
 160                     return jjMoveStringLiteralDfa2_0(active0, 0x2L);\r
 161                                 \r
 162                 default: \r
 163                     break;\r
 164                                 \r
 165             }\r
 166             return jjStartNfa_0(0, active0);\r
 167         }\r
 168         private int jjMoveStringLiteralDfa2_0(long old0, long active0)\r
 169         {\r
 170             if (((active0 &= old0)) == 0L)\r
 171                 return jjStartNfa_0(0, old0);\r
 172             try\r
 173             {\r
 174                 curChar = input_stream.ReadChar();\r
 175             }\r
 176             catch (System.IO.IOException e)\r
 177             {\r
 178                 jjStopStringLiteralDfa_0(1, active0);\r
 179                 return 2;\r
 180             }\r
 181             switch (curChar)\r
 182             {\r
 183                                 \r
 184                 case (char) (45): \r
 185                     return jjMoveStringLiteralDfa3_0(active0, 0x10L);\r
 186                                 \r
 187                 case (char) (99): \r
 188                     return jjMoveStringLiteralDfa3_0(active0, 0x2L);\r
 189                                 \r
 190                 default: \r
 191                     break;\r
 192                                 \r
 193             }\r
 194             return jjStartNfa_0(1, active0);\r
 195         }\r
 196         private int jjMoveStringLiteralDfa3_0(long old0, long active0)\r
 197         {\r
 198             if (((active0 &= old0)) == 0L)\r
 199                 return jjStartNfa_0(1, old0);\r
 200             try\r
 201             {\r
 202                 curChar = input_stream.ReadChar();\r
 203             }\r
 204             catch (System.IO.IOException e)\r
 205             {\r
 206                 jjStopStringLiteralDfa_0(2, active0);\r
 207                 return 3;\r
 208             }\r
 209             switch (curChar)\r
 210             {\r
 211                                 \r
 212                 case (char) (45): \r
 213                     if ((active0 & 0x10L) != 0L)\r
 214                         return jjStopAtPos(3, 4);\r
 215                     break;\r
 216                                 \r
 217                 case (char) (114): \r
 218                     return jjMoveStringLiteralDfa4_0(active0, 0x2L);\r
 219                                 \r
 220                 default: \r
 221                     break;\r
 222                                 \r
 223             }\r
 224             return jjStartNfa_0(2, active0);\r
 225         }\r
 226         private int jjMoveStringLiteralDfa4_0(long old0, long active0)\r
 227         {\r
 228             if (((active0 &= old0)) == 0L)\r
 229                 return jjStartNfa_0(2, old0);\r
 230             try\r
 231             {\r
 232                 curChar = input_stream.ReadChar();\r
 233             }\r
 234             catch (System.IO.IOException e)\r
 235             {\r
 236                 jjStopStringLiteralDfa_0(3, active0);\r
 237                 return 4;\r
 238             }\r
 239             switch (curChar)\r
 240             {\r
 241                                 \r
 242                 case (char) (105): \r
 243                     return jjMoveStringLiteralDfa5_0(active0, 0x2L);\r
 244                                 \r
 245                 default: \r
 246                     break;\r
 247                                 \r
 248             }\r
 249             return jjStartNfa_0(3, active0);\r
 250         }\r
 251         private int jjMoveStringLiteralDfa5_0(long old0, long active0)\r
 252         {\r
 253             if (((active0 &= old0)) == 0L)\r
 254                 return jjStartNfa_0(3, old0);\r
 255             try\r
 256             {\r
 257                 curChar = input_stream.ReadChar();\r
 258             }\r
 259             catch (System.IO.IOException e)\r
 260             {\r
 261                 jjStopStringLiteralDfa_0(4, active0);\r
 262                 return 5;\r
 263             }\r
 264             switch (curChar)\r
 265             {\r
 266                                 \r
 267                 case (char) (112): \r
 268                     return jjMoveStringLiteralDfa6_0(active0, 0x2L);\r
 269                                 \r
 270                 default: \r
 271                     break;\r
 272                                 \r
 273             }\r
 274             return jjStartNfa_0(4, active0);\r
 275         }\r
 276         private int jjMoveStringLiteralDfa6_0(long old0, long active0)\r
 277         {\r
 278             if (((active0 &= old0)) == 0L)\r
 279                 return jjStartNfa_0(4, old0);\r
 280             try\r
 281             {\r
 282                 curChar = input_stream.ReadChar();\r
 283             }\r
 284             catch (System.IO.IOException e)\r
 285             {\r
 286                 jjStopStringLiteralDfa_0(5, active0);\r
 287                 return 6;\r
 288             }\r
 289             switch (curChar)\r
 290             {\r
 291                                 \r
 292                 case (char) (116): \r
 293                     if ((active0 & 0x2L) != 0L)\r
 294                         return jjStartNfaWithStates_0(6, 1, 20);\r
 295                     break;\r
 296                                 \r
 297                 default: \r
 298                     break;\r
 299                                 \r
 300             }\r
 301             return jjStartNfa_0(5, active0);\r
 302         }\r
 303         private void  jjCheckNAdd(int state)\r
 304         {\r
 305             if (jjrounds[state] != jjround)\r
 306             {\r
 307                 jjstateSet[jjnewStateCnt++] = state;\r
 308                 jjrounds[state] = jjround;\r
 309             }\r
 310         }\r
 311         private void  jjAddStates(int start, int end)\r
 312         {\r
 313             do \r
 314             {\r
 315                 jjstateSet[jjnewStateCnt++] = jjnextStates[start];\r
 316             }\r
 317             while (start++ != end);\r
 318         }\r
 319         private void  jjCheckNAddTwoStates(int state1, int state2)\r
 320         {\r
 321             jjCheckNAdd(state1);\r
 322             jjCheckNAdd(state2);\r
 323         }\r
 324         private void  jjCheckNAddStates(int start, int end)\r
 325         {\r
 326             do \r
 327             {\r
 328                 jjCheckNAdd(jjnextStates[start]);\r
 329             }\r
 330             while (start++ != end);\r
 331         }\r
 332         private void  jjCheckNAddStates(int start)\r
 333         {\r
 334             jjCheckNAdd(jjnextStates[start]);\r
 335             jjCheckNAdd(jjnextStates[start + 1]);\r
 336         }\r
 337         internal static readonly ulong[] jjbitVec0 = new ulong[]{0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL};\r
 338         private int jjMoveNfa_0(int startState, int curPos)\r
 339         {\r
 340             int[] nextStates;\r
 341             int startsAt = 0;\r
 342             jjnewStateCnt = 25;\r
 343             int i = 1;\r
 344             jjstateSet[0] = startState;\r
 345             int j, kind = 0x7fffffff;\r
 346             for (; ; )\r
 347             {\r
 348                 if (++jjround == 0x7fffffff)\r
 349                     ReInitRounds();\r
 350                 if (curChar < 64)\r
 351                 {\r
 352                     ulong l = ((ulong) 1L) << curChar;\r\r
 353 MatchLoop: \r
 354                     do \r
 355                     {\r
 356                         switch (jjstateSet[--i])\r
 357                         {\r
 358                                                         \r
 359                             case 11: \r
 360                                 if ((0x3ff000000000000L & l) != 0L)\r
 361                                     jjCheckNAddTwoStates(7, 2);\r
 362                                 else if ((0x100002600L & l) != 0L)\r
 363                                 {\r
 364                                     if (kind > 10)\r
 365                                         kind = 10;\r
 366                                     jjCheckNAdd(10);\r
 367                                 }\r
 368                                 else if (curChar == 60)\r
 369                                     jjCheckNAddStates(0, 2);\r
 370                                 else if (curChar == 38)\r
 371                                     jjAddStates(3, 4);\r
 372                                 else if (curChar == 36)\r
 373                                     jjstateSet[jjnewStateCnt++] = 1;\r
 374                                 if ((0x3ff000000000000L & l) != 0L)\r
 375                                 {\r
 376                                     if (kind > 6)\r
 377                                         kind = 6;\r
 378                                     jjCheckNAddStates(5, 9);\r
 379                                 }\r
 380                                 break;\r
 381                                                         \r
 382                             case 17: \r
 383                                 if (curChar == 33)\r
 384                                     jjstateSet[jjnewStateCnt++] = 22;\r
 385                                 else if (curChar == 47)\r
 386                                     jjCheckNAdd(18);\r
 387                                 break;\r
 388                                                         \r
 389                             case 0: \r
 390                                 if (curChar == 36)\r
 391                                     jjstateSet[jjnewStateCnt++] = 1;\r
 392                                 break;\r
 393                                                         \r
 394                             case 1: \r
 395                                 if ((0x3ff000000000000L & l) != 0L)\r
 396                                     jjCheckNAdd(2);\r
 397                                 break;\r
 398                                                         \r
 399                             case 2: \r
 400                                 if ((0x500000000000L & l) != 0L)\r
 401                                     jjstateSet[jjnewStateCnt++] = 3;\r
 402                                 break;\r
 403                                                         \r
 404                             case 3: \r
 405                             case 9: \r
 406                                 if ((0x3ff000000000000L & l) == 0L)\r
 407                                     break;\r
 408                                 if (kind > 6)\r
 409                                     kind = 6;\r
 410                                 jjCheckNAddStates(10, 12);\r
 411                                 break;\r
 412                                                         \r
 413                             case 4: \r
 414                                 if ((0x3ff000000000000L & l) == 0L)\r
 415                                     break;\r
 416                                 if (kind > 6)\r
 417                                     kind = 6;\r
 418                                 jjCheckNAddStates(5, 9);\r
 419                                 break;\r
 420                                                         \r
 421                             case 5: \r
 422                                 if ((0x880000000000L & l) == 0L)\r
 423                                     break;\r
 424                                 if (kind > 6)\r
 425                                     kind = 6;\r
 426                                 jjCheckNAddStates(13, 16);\r
 427                                 break;\r
 428                                                         \r
 429                             case 6: \r
 430                                 if ((0x3ff000000000000L & l) != 0L)\r
 431                                     jjCheckNAddTwoStates(7, 2);\r
 432                                 break;\r
 433                                                         \r
 434                             case 7: \r
 435                                 if (curChar != 34)\r
 436                                     break;\r
 437                                 if (kind > 6)\r
 438                                     kind = 6;\r
 439                                 jjCheckNAddStates(10, 12);\r
 440                                 break;\r
 441                                                         \r
 442                             case 8: \r
 443                                 if ((0x208000000000L & l) != 0L)\r
 444                                     jjstateSet[jjnewStateCnt++] = 9;\r
 445                                 break;\r
 446                                                         \r
 447                             case 10: \r
 448                                 if ((0x100002600L & l) == 0L)\r
 449                                     break;\r
 450                                 kind = 10;\r
 451                                 jjCheckNAdd(10);\r
 452                                 break;\r
 453                                                         \r
 454                             case 13: \r
 455                                 if (curChar == 59 && kind > 9)\r
 456                                     kind = 9;\r
 457                                 break;\r
 458                                                         \r
 459                             case 14: \r
 460                                 if (curChar == 35)\r
 461                                     jjCheckNAdd(15);\r
 462                                 break;\r
 463                                                         \r
 464                             case 15: \r
 465                                 if ((0x3ff000000000000L & l) == 0L)\r
 466                                     break;\r
 467                                 if (kind > 9)\r
 468                                     kind = 9;\r
 469                                 jjCheckNAddTwoStates(15, 13);\r
 470                                 break;\r
 471                                                         \r
 472                             case 16: \r
 473                                 if (curChar == 60)\r
 474                                     jjCheckNAddStates(0, 2);\r
 475                                 break;\r
 476                                                         \r
 477                             case 19: \r
 478                                 if ((0x9fffff7affffd9ffL & l) == 0L)\r
 479                                     break;\r
 480                                 if (kind > 2)\r
 481                                     kind = 2;\r
 482                                 jjCheckNAdd(20);\r
 483                                 break;\r
 484                                                         \r
 485                             case 20: \r
 486                                 if ((0x9ffffffeffffd9ffL & l) == 0L)\r
 487                                     break;\r
 488                                 if (kind > 2)\r
 489                                     kind = 2;\r
 490                                 jjCheckNAdd(20);\r
 491                                 break;\r
 492                                                         \r
 493                             case 21: \r
 494                                 if (curChar == 33)\r
 495                                     jjstateSet[jjnewStateCnt++] = 22;\r
 496                                 break;\r
 497                                                         \r
 498                             case 23: \r
 499                                 if ((0x9fffff7affffd9ffL & l) == 0L)\r
 500                                     break;\r
 501                                 if (kind > 3)\r
 502                                     kind = 3;\r
 503                                 jjCheckNAdd(24);\r
 504                                 break;\r
 505                                                         \r
 506                             case 24: \r
 507                                 if ((0x9ffffffeffffd9ffL & l) == 0L)\r
 508                                     break;\r
 509                                 if (kind > 3)\r
 510                                     kind = 3;\r
 511                                 jjCheckNAdd(24);\r
 512                                 break;\r
 513                                                         \r
 514                             default:  break;\r
 515                                                         \r
 516                         }\r
 517                     }\r
 518                     while (i != startsAt);\r
 519                 }\r
 520                 else if (curChar < 128)\r
 521                 {\r
 522                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
 523 MatchLoop1: \r
 524                     do \r
 525                     {\r
 526                         switch (jjstateSet[--i])\r
 527                         {\r
 528                                                         \r
 529                             case 11: \r
 530                             case 4: \r
 531                                 if ((0x7fffffe07fffffeL & l) == 0L)\r
 532                                     break;\r
 533                                 if (kind > 6)\r
 534                                     kind = 6;\r
 535                                 jjCheckNAddStates(5, 9);\r
 536                                 break;\r
 537                                                         \r
 538                             case 17: \r
 539                             case 18: \r
 540                                 if ((0x7fffffe07fffffeL & l) == 0L)\r
 541                                     break;\r
 542                                 if (kind > 2)\r
 543                                     kind = 2;\r
 544                                 jjstateSet[jjnewStateCnt++] = 19;\r
 545                                 break;\r
 546                                                         \r
 547                             case 9: \r
 548                                 if ((0x7fffffe07fffffeL & l) == 0L)\r
 549                                     break;\r
 550                                 if (kind > 6)\r
 551                                     kind = 6;\r
 552                                 jjCheckNAddStates(10, 12);\r
 553                                 break;\r
 554                                                         \r
 555                             case 12: \r
 556                                 if ((0x7fffffe07fffffeL & l) == 0L)\r
 557                                     break;\r
 558                                 if (kind > 9)\r
 559                                     kind = 9;\r
 560                                 jjAddStates(17, 18);\r
 561                                 break;\r
 562                                                         \r
 563                             case 19: \r
 564                             case 20: \r
 565                                 if (kind > 2)\r
 566                                     kind = 2;\r
 567                                 jjCheckNAdd(20);\r
 568                                 break;\r
 569                                                         \r
 570                             case 22: \r
 571                                 if ((0x7fffffe07fffffeL & l) == 0L)\r
 572                                     break;\r
 573                                 if (kind > 3)\r
 574                                     kind = 3;\r
 575                                 jjstateSet[jjnewStateCnt++] = 23;\r
 576                                 break;\r
 577                                                         \r
 578                             case 23: \r
 579                             case 24: \r
 580                                 if (kind > 3)\r
 581                                     kind = 3;\r
 582                                 jjCheckNAdd(24);\r
 583                                 break;\r
 584                                                         \r
 585                             default:  break;\r
 586                                                         \r
 587                         }\r
 588                     }\r
 589                     while (i != startsAt);\r
 590                 }\r
 591                 else\r
 592                 {\r
 593                     int i2 = (curChar & 0xff) >> 6;\r
 594                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
 595                 MatchLoop1: \r
 596                     do \r
 597                     {\r
 598                         switch (jjstateSet[--i])\r
 599                         {\r
 600                                                         \r
 601                             case 19: \r
 602                             case 20: \r
 603                                 if ((jjbitVec0[i2] & l2) == 0L)\r
 604                                     break;\r
 605                                 if (kind > 2)\r
 606                                     kind = 2;\r
 607                                 jjCheckNAdd(20);\r
 608                                 break;\r
 609                                                         \r
 610                             case 23: \r
 611                             case 24: \r
 612                                 if ((jjbitVec0[i2] & l2) == 0L)\r
 613                                     break;\r
 614                                 if (kind > 3)\r
 615                                     kind = 3;\r
 616                                 jjCheckNAdd(24);\r
 617                                 break;\r
 618                                                         \r
 619                             default:  break;\r
 620                                                         \r
 621                         }\r
 622                     }\r
 623                     while (i != startsAt);\r
 624                 }\r
 625                 if (kind != 0x7fffffff)\r
 626                 {\r
 627                     jjmatchedKind = kind;\r
 628                     jjmatchedPos = curPos;\r
 629                     kind = 0x7fffffff;\r
 630                 }\r
 631                 ++curPos;\r
 632                 if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))\r
 633                     return curPos;\r
 634                 try\r
 635                 {\r
 636                     curChar = input_stream.ReadChar();\r
 637                 }\r
 638                 catch (System.IO.IOException e)\r
 639                 {\r
 640                     return curPos;\r
 641                 }\r
 642             }\r
 643         }\r
 644         private int jjMoveStringLiteralDfa0_5()\r
 645         {\r
 646             return jjMoveNfa_5(1, 0);\r
 647         }\r
 648         private int jjMoveNfa_5(int startState, int curPos)\r
 649         {\r
 650             int[] nextStates;\r
 651             int startsAt = 0;\r
 652             jjnewStateCnt = 2;\r
 653             int i = 1;\r
 654             jjstateSet[0] = startState;\r
 655             int j, kind = 0x7fffffff;\r
 656             for (; ; )\r
 657             {\r
 658                 if (++jjround == 0x7fffffff)\r
 659                     ReInitRounds();\r
 660                 if (curChar < 64)\r
 661                 {\r
 662                     ulong l = ((ulong) 1L) << curChar;\r\r
 663 MatchLoop1: \r
 664                     do \r
 665                     {\r
 666                         switch (jjstateSet[--i])\r
 667                         {\r
 668                                                         \r
 669                             case 1: \r
 670                                 if ((0xfffffffbffffffffL & l) != 0L)\r
 671                                 {\r
 672                                     if (kind > 24)\r
 673                                         kind = 24;\r
 674                                     jjCheckNAdd(0);\r
 675                                 }\r
 676                                 else if (curChar == 34)\r
 677                                 {\r
 678                                     if (kind > 25)\r
 679                                         kind = 25;\r
 680                                 }\r
 681                                 break;\r
 682                                                         \r
 683                             case 0: \r
 684                                 if ((0xfffffffbffffffffL & l) == 0L)\r
 685                                     break;\r
 686                                 kind = 24;\r
 687                                 jjCheckNAdd(0);\r
 688                                 break;\r
 689                                                         \r
 690                             default:  break;\r
 691                                                         \r
 692                         }\r
 693                     }\r
 694                     while (i != startsAt);\r
 695                 }\r
 696                 else if (curChar < 128)\r
 697                 {\r
 698                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
 699 MatchLoop1: \r
 700                     do \r
 701                     {\r
 702                         switch (jjstateSet[--i])\r
 703                         {\r
 704                                                         \r
 705                             case 1: \r
 706                             case 0: \r
 707                                 kind = 24;\r
 708                                 jjCheckNAdd(0);\r
 709                                 break;\r
 710                                                         \r
 711                             default:  break;\r
 712                                                         \r
 713                         }\r
 714                     }\r
 715                     while (i != startsAt);\r
 716                 }\r
 717                 else\r
 718                 {\r
 719                     int i2 = (curChar & 0xff) >> 6;\r
 720                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
 721                 MatchLoop1: \r
 722                     do \r
 723                     {\r
 724                         switch (jjstateSet[--i])\r
 725                         {\r
 726                                                         \r
 727                             case 1: \r
 728                             case 0: \r
 729                                 if ((jjbitVec0[i2] & l2) == 0L)\r
 730                                     break;\r
 731                                 if (kind > 24)\r
 732                                     kind = 24;\r
 733                                 jjCheckNAdd(0);\r
 734                                 break;\r
 735                                                         \r
 736                             default:  break;\r
 737                                                         \r
 738                         }\r
 739                     }\r
 740                     while (i != startsAt);\r
 741                 }\r
 742                 if (kind != 0x7fffffff)\r
 743                 {\r
 744                     jjmatchedKind = kind;\r
 745                     jjmatchedPos = curPos;\r
 746                     kind = 0x7fffffff;\r
 747                 }\r
 748                 ++curPos;\r
 749                 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))\r
 750                     return curPos;\r
 751                 try\r
 752                 {\r
 753                     curChar = input_stream.ReadChar();\r
 754                 }\r
 755                 catch (System.IO.IOException e)\r
 756                 {\r
 757                     return curPos;\r
 758                 }\r
 759             }\r
 760         }\r
 761         private int jjStopStringLiteralDfa_7(int pos, long active0)\r
 762         {\r
 763             switch (pos)\r
 764             {\r
 765                                 \r
 766                 default: \r
 767                     return - 1;\r
 768                                 \r
 769             }\r
 770         }\r
 771         private int jjStartNfa_7(int pos, long active0)\r
 772         {\r
 773             return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);\r
 774         }\r
 775         private int jjStartNfaWithStates_7(int pos, int kind, int state)\r
 776         {\r
 777             jjmatchedKind = kind;\r
 778             jjmatchedPos = pos;\r
 779             try\r
 780             {\r
 781                 curChar = input_stream.ReadChar();\r
 782             }\r
 783             catch (System.IO.IOException e)\r
 784             {\r
 785                 return pos + 1;\r
 786             }\r
 787             return jjMoveNfa_7(state, pos + 1);\r
 788         }\r
 789         private int jjMoveStringLiteralDfa0_7()\r
 790         {\r
 791             switch (curChar)\r
 792             {\r
 793                                 \r
 794                 case (char) (62): \r
 795                     return jjStopAtPos(0, 29);\r
 796                                 \r
 797                 default: \r
 798                     return jjMoveNfa_7(0, 0);\r
 799                                 \r
 800             }\r
 801         }\r
 802         private int jjMoveNfa_7(int startState, int curPos)\r
 803         {\r
 804             int[] nextStates;\r
 805             int startsAt = 0;\r
 806             jjnewStateCnt = 1;\r
 807             int i = 1;\r
 808             jjstateSet[0] = startState;\r
 809             int j, kind = 0x7fffffff;\r
 810             for (; ; )\r
 811             {\r
 812                 if (++jjround == 0x7fffffff)\r
 813                     ReInitRounds();\r
 814                 if (curChar < 64)\r
 815                 {\r
 816                     ulong l = ((ulong) 1L) << curChar;\r\r
 817 MatchLoop1: \r
 818                     do \r
 819                     {\r
 820                         switch (jjstateSet[--i])\r
 821                         {\r
 822                                                         \r
 823                             case 0: \r
 824                                 if ((0xbfffffffffffffffL & l) == 0L)\r
 825                                     break;\r
 826                                 kind = 28;\r
 827                                 jjstateSet[jjnewStateCnt++] = 0;\r
 828                                 break;\r
 829                                                         \r
 830                             default:  break;\r
 831                                                         \r
 832                         }\r
 833                     }\r
 834                     while (i != startsAt);\r
 835                 }\r
 836                 else if (curChar < 128)\r
 837                 {\r
 838                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
 839 MatchLoop1: \r
 840                     do \r
 841                     {\r
 842                         switch (jjstateSet[--i])\r
 843                         {\r
 844                                                         \r
 845                             case 0: \r
 846                                 kind = 28;\r
 847                                 jjstateSet[jjnewStateCnt++] = 0;\r
 848                                 break;\r
 849                                                         \r
 850                             default:  break;\r
 851                                                         \r
 852                         }\r
 853                     }\r
 854                     while (i != startsAt);\r
 855                 }\r
 856                 else\r
 857                 {\r
 858                     int i2 = (curChar & 0xff) >> 6;\r
 859                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
 860                 MatchLoop1: \r
 861                     do \r
 862                     {\r
 863                         switch (jjstateSet[--i])\r
 864                         {\r
 865                                                         \r
 866                             case 0: \r
 867                                 if ((jjbitVec0[i2] & l2) == 0L)\r
 868                                     break;\r
 869                                 if (kind > 28)\r
 870                                     kind = 28;\r
 871                                 jjstateSet[jjnewStateCnt++] = 0;\r
 872                                 break;\r
 873                                                         \r
 874                             default:  break;\r
 875                                                         \r
 876                         }\r
 877                     }\r
 878                     while (i != startsAt);\r
 879                 }\r
 880                 if (kind != 0x7fffffff)\r
 881                 {\r
 882                     jjmatchedKind = kind;\r
 883                     jjmatchedPos = curPos;\r
 884                     kind = 0x7fffffff;\r
 885                 }\r
 886                 ++curPos;\r
 887                 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))\r
 888                     return curPos;\r
 889                 try\r
 890                 {\r
 891                     curChar = input_stream.ReadChar();\r
 892                 }\r
 893                 catch (System.IO.IOException e)\r
 894                 {\r
 895                     return curPos;\r
 896                 }\r
 897             }\r
 898         }\r
 899         private int jjMoveStringLiteralDfa0_4()\r
 900         {\r
 901             return jjMoveNfa_4(1, 0);\r
 902         }\r
 903         private int jjMoveNfa_4(int startState, int curPos)\r
 904         {\r
 905             int[] nextStates;\r
 906             int startsAt = 0;\r
 907             jjnewStateCnt = 2;\r
 908             int i = 1;\r
 909             jjstateSet[0] = startState;\r
 910             int j, kind = 0x7fffffff;\r
 911             for (; ; )\r
 912             {\r
 913                 if (++jjround == 0x7fffffff)\r
 914                     ReInitRounds();\r
 915                 if (curChar < 64)\r
 916                 {\r
 917                     ulong l = ((ulong) 1L) << curChar;\r\r
 918 MatchLoop1: \r
 919                     do \r
 920                     {\r
 921                         switch (jjstateSet[--i])\r
 922                         {\r
 923                                                         \r
 924                             case 1: \r
 925                                 if ((0xffffff7fffffffffL & l) != 0L)\r
 926                                 {\r
 927                                     if (kind > 22)\r
 928                                         kind = 22;\r
 929                                     jjCheckNAdd(0);\r
 930                                 }\r
 931                                 else if (curChar == 39)\r
 932                                 {\r
 933                                     if (kind > 23)\r
 934                                         kind = 23;\r
 935                                 }\r
 936                                 break;\r
 937                                                         \r
 938                             case 0: \r
 939                                 if ((0xffffff7fffffffffL & l) == 0L)\r
 940                                     break;\r
 941                                 kind = 22;\r
 942                                 jjCheckNAdd(0);\r
 943                                 break;\r
 944                                                         \r
 945                             default:  break;\r
 946                                                         \r
 947                         }\r
 948                     }\r
 949                     while (i != startsAt);\r
 950                 }\r
 951                 else if (curChar < 128)\r
 952                 {\r
 953                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
 954 MatchLoop1: \r
 955                     do \r
 956                     {\r
 957                         switch (jjstateSet[--i])\r
 958                         {\r
 959                                                         \r
 960                             case 1: \r
 961                             case 0: \r
 962                                 kind = 22;\r
 963                                 jjCheckNAdd(0);\r
 964                                 break;\r
 965                                                         \r
 966                             default:  break;\r
 967                                                         \r
 968                         }\r
 969                     }\r
 970                     while (i != startsAt);\r
 971                 }\r
 972                 else\r
 973                 {\r
 974                     int i2 = (curChar & 0xff) >> 6;\r
 975                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
 976                 MatchLoop1: \r
 977                     do \r
 978                     {\r
 979                         switch (jjstateSet[--i])\r
 980                         {\r
 981                                                         \r
 982                             case 1: \r
 983                             case 0: \r
 984                                 if ((jjbitVec0[i2] & l2) == 0L)\r
 985                                     break;\r
 986                                 if (kind > 22)\r
 987                                     kind = 22;\r
 988                                 jjCheckNAdd(0);\r
 989                                 break;\r
 990                                                         \r
 991                             default:  break;\r
 992                                                         \r
 993                         }\r
 994                     }\r
 995                     while (i != startsAt);\r
 996                 }\r
 997                 if (kind != 0x7fffffff)\r
 998                 {\r
 999                     jjmatchedKind = kind;\r
1000                     jjmatchedPos = curPos;\r
1001                     kind = 0x7fffffff;\r
1002                 }\r
1003                 ++curPos;\r
1004                 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))\r
1005                     return curPos;\r
1006                 try\r
1007                 {\r
1008                     curChar = input_stream.ReadChar();\r
1009                 }\r
1010                 catch (System.IO.IOException e)\r
1011                 {\r
1012                     return curPos;\r
1013                 }\r
1014             }\r
1015         }\r
1016         private int jjStopStringLiteralDfa_3(int pos, long active0)\r
1017         {\r
1018             switch (pos)\r
1019             {\r
1020                                 \r
1021                 default: \r
1022                     return - 1;\r
1023                                 \r
1024             }\r
1025         }\r
1026         private int jjStartNfa_3(int pos, long active0)\r
1027         {\r
1028             return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);\r
1029         }\r
1030         private int jjStartNfaWithStates_3(int pos, int kind, int state)\r
1031         {\r
1032             jjmatchedKind = kind;\r
1033             jjmatchedPos = pos;\r
1034             try\r
1035             {\r
1036                 curChar = input_stream.ReadChar();\r
1037             }\r
1038             catch (System.IO.IOException e)\r
1039             {\r
1040                 return pos + 1;\r
1041             }\r
1042             return jjMoveNfa_3(state, pos + 1);\r
1043         }\r
1044         private int jjMoveStringLiteralDfa0_3()\r
1045         {\r
1046             switch (curChar)\r
1047             {\r
1048                                 \r
1049                 case (char) (34): \r
1050                     return jjStopAtPos(0, 20);\r
1051                                 \r
1052                 case (char) (39): \r
1053                     return jjStopAtPos(0, 19);\r
1054                                 \r
1055                 default: \r
1056                     return jjMoveNfa_3(0, 0);\r
1057                                 \r
1058             }\r
1059         }\r
1060         private int jjMoveNfa_3(int startState, int curPos)\r
1061         {\r
1062             int[] nextStates;\r
1063             int startsAt = 0;\r
1064             jjnewStateCnt = 3;\r
1065             int i = 1;\r
1066             jjstateSet[0] = startState;\r
1067             int j, kind = 0x7fffffff;\r
1068             for (; ; )\r
1069             {\r
1070                 if (++jjround == 0x7fffffff)\r
1071                     ReInitRounds();\r
1072                 if (curChar < 64)\r
1073                 {\r
1074                     ulong l = ((ulong) 1L) << (int) curChar;\r\r
1075 MatchLoop1: \r
1076                     do \r
1077                     {\r
1078                         switch (jjstateSet[--i])\r
1079                         {\r
1080                                                         \r
1081                             case 0: \r
1082                                 if ((0x9fffff7affffd9ffL & l) != 0L)\r
1083                                 {\r
1084                                     if (kind > 18)\r
1085                                         kind = 18;\r
1086                                     jjCheckNAdd(1);\r
1087                                 }\r
1088                                 else if ((0x100002600L & l) != 0L)\r
1089                                 {\r
1090                                     if (kind > 21)\r
1091                                         kind = 21;\r
1092                                     jjCheckNAdd(2);\r
1093                                 }\r
1094                                 break;\r
1095                                                         \r
1096                             case 1: \r
1097                                 if ((0xbffffffeffffd9ffL & l) == 0L)\r
1098                                     break;\r
1099                                 if (kind > 18)\r
1100                                     kind = 18;\r
1101                                 jjCheckNAdd(1);\r
1102                                 break;\r
1103                                                         \r
1104                             case 2: \r
1105                                 if ((0x100002600L & l) == 0L)\r
1106                                     break;\r
1107                                 kind = 21;\r
1108                                 jjCheckNAdd(2);\r
1109                                 break;\r
1110                                                         \r
1111                             default:  break;\r
1112                                                         \r
1113                         }\r
1114                     }\r
1115                     while (i != startsAt);\r
1116                 }\r
1117                 else if (curChar < 128)\r
1118                 {\r
1119                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
1120 MatchLoop1: \r
1121                     do \r
1122                     {\r
1123                         switch (jjstateSet[--i])\r
1124                         {\r
1125                                                         \r
1126                             case 0: \r
1127                             case 1: \r
1128                                 if (kind > 18)\r
1129                                     kind = 18;\r
1130                                 jjCheckNAdd(1);\r
1131                                 break;\r
1132                                                         \r
1133                             default:  break;\r
1134                                                         \r
1135                         }\r
1136                     }\r
1137                     while (i != startsAt);\r
1138                 }\r
1139                 else\r
1140                 {\r
1141                     int i2 = (curChar & 0xff) >> 6;\r
1142                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
1143                 MatchLoop1: \r
1144                     do \r
1145                     {\r
1146                         switch (jjstateSet[--i])\r
1147                         {\r
1148                                                         \r
1149                             case 0: \r
1150                             case 1: \r
1151                                 if ((jjbitVec0[i2] & l2) == 0L)\r
1152                                     break;\r
1153                                 if (kind > 18)\r
1154                                     kind = 18;\r
1155                                 jjCheckNAdd(1);\r
1156                                 break;\r
1157                                                         \r
1158                             default:  break;\r
1159                                                         \r
1160                         }\r
1161                     }\r
1162                     while (i != startsAt);\r
1163                 }\r
1164                 if (kind != 0x7fffffff)\r
1165                 {\r
1166                     jjmatchedKind = kind;\r
1167                     jjmatchedPos = curPos;\r
1168                     kind = 0x7fffffff;\r
1169                 }\r
1170                 ++curPos;\r
1171                 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))\r
1172                     return curPos;\r
1173                 try\r
1174                 {\r
1175                     curChar = input_stream.ReadChar();\r
1176                 }\r
1177                 catch (System.IO.IOException e)\r
1178                 {\r
1179                     return curPos;\r
1180                 }\r
1181             }\r
1182         }\r
1183         private int jjStopStringLiteralDfa_6(int pos, long active0)\r
1184         {\r
1185             switch (pos)\r
1186             {\r
1187                                 \r
1188                 case 0: \r
1189                     if ((active0 & 0x8000000L) != 0L)\r
1190                     {\r
1191                         jjmatchedKind = 26;\r
1192                         return - 1;\r
1193                     }\r
1194                     return - 1;\r
1195                                 \r
1196                 case 1: \r
1197                     if ((active0 & 0x8000000L) != 0L)\r
1198                     {\r
1199                         if (jjmatchedPos == 0)\r
1200                         {\r
1201                             jjmatchedKind = 26;\r
1202                             jjmatchedPos = 0;\r
1203                         }\r
1204                         return - 1;\r
1205                     }\r
1206                     return - 1;\r
1207                                 \r
1208                 default: \r
1209                     return - 1;\r
1210                                 \r
1211             }\r
1212         }\r
1213         private int jjStartNfa_6(int pos, long active0)\r
1214         {\r
1215             return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);\r
1216         }\r
1217         private int jjStartNfaWithStates_6(int pos, int kind, int state)\r
1218         {\r
1219             jjmatchedKind = kind;\r
1220             jjmatchedPos = pos;\r
1221             try\r
1222             {\r
1223                 curChar = input_stream.ReadChar();\r
1224             }\r
1225             catch (System.IO.IOException e)\r
1226             {\r
1227                 return pos + 1;\r
1228             }\r
1229             return jjMoveNfa_6(state, pos + 1);\r
1230         }\r
1231         private int jjMoveStringLiteralDfa0_6()\r
1232         {\r
1233             switch (curChar)\r
1234             {\r
1235                                 \r
1236                 case (char) (45): \r
1237                     return jjMoveStringLiteralDfa1_6(0x8000000L);\r
1238                                 \r
1239                 default: \r
1240                     return jjMoveNfa_6(1, 0);\r
1241                                 \r
1242             }\r
1243         }\r
1244         private int jjMoveStringLiteralDfa1_6(long active0)\r
1245         {\r
1246             try\r
1247             {\r
1248                 curChar = input_stream.ReadChar();\r
1249             }\r
1250             catch (System.IO.IOException e)\r
1251             {\r
1252                 jjStopStringLiteralDfa_6(0, active0);\r
1253                 return 1;\r
1254             }\r
1255             switch (curChar)\r
1256             {\r
1257                                 \r
1258                 case (char) (45): \r
1259                     return jjMoveStringLiteralDfa2_6(active0, 0x8000000L);\r
1260                                 \r
1261                 default: \r
1262                     break;\r
1263                                 \r
1264             }\r
1265             return jjStartNfa_6(0, active0);\r
1266         }\r
1267         private int jjMoveStringLiteralDfa2_6(long old0, long active0)\r
1268         {\r
1269             if (((active0 &= old0)) == 0L)\r
1270                 return jjStartNfa_6(0, old0);\r
1271             try\r
1272             {\r
1273                 curChar = input_stream.ReadChar();\r
1274             }\r
1275             catch (System.IO.IOException e)\r
1276             {\r
1277                 jjStopStringLiteralDfa_6(1, active0);\r
1278                 return 2;\r
1279             }\r
1280             switch (curChar)\r
1281             {\r
1282                                 \r
1283                 case (char) (62): \r
1284                     if ((active0 & 0x8000000L) != 0L)\r
1285                         return jjStopAtPos(2, 27);\r
1286                     break;\r
1287                                 \r
1288                 default: \r
1289                     break;\r
1290                                 \r
1291             }\r
1292             return jjStartNfa_6(1, active0);\r
1293         }\r
1294         private int jjMoveNfa_6(int startState, int curPos)\r
1295         {\r
1296             int[] nextStates;\r
1297             int startsAt = 0;\r
1298             jjnewStateCnt = 2;\r
1299             int i = 1;\r
1300             jjstateSet[0] = startState;\r
1301             int j, kind = 0x7fffffff;\r
1302             for (; ; )\r
1303             {\r
1304                 if (++jjround == 0x7fffffff)\r
1305                     ReInitRounds();\r
1306                 if (curChar < 64)\r
1307                 {\r
1308                     ulong l = ((ulong) 1L) << curChar;\r\r
1309 MatchLoop1: \r
1310                     do \r
1311                     {\r
1312                         switch (jjstateSet[--i])\r
1313                         {\r
1314                                                         \r
1315                             case 1: \r
1316                                 if ((0xffffdfffffffffffL & l) != 0L)\r
1317                                 {\r
1318                                     if (kind > 26)\r
1319                                         kind = 26;\r
1320                                     jjCheckNAdd(0);\r
1321                                 }\r
1322                                 else if (curChar == 45)\r
1323                                 {\r
1324                                     if (kind > 26)\r
1325                                         kind = 26;\r
1326                                 }\r
1327                                 break;\r
1328                                                         \r
1329                             case 0: \r
1330                                 if ((0xffffdfffffffffffL & l) == 0L)\r
1331                                     break;\r
1332                                 kind = 26;\r
1333                                 jjCheckNAdd(0);\r
1334                                 break;\r
1335                                                         \r
1336                             default:  break;\r
1337                                                         \r
1338                         }\r
1339                     }\r
1340                     while (i != startsAt);\r
1341                 }\r
1342                 else if (curChar < 128)\r
1343                 {\r
1344                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
1345 MatchLoop1: \r
1346                     do \r
1347                     {\r
1348                         switch (jjstateSet[--i])\r
1349                         {\r
1350                                                         \r
1351                             case 1: \r
1352                             case 0: \r
1353                                 kind = 26;\r
1354                                 jjCheckNAdd(0);\r
1355                                 break;\r
1356                                                         \r
1357                             default:  break;\r
1358                                                         \r
1359                         }\r
1360                     }\r
1361                     while (i != startsAt);\r
1362                 }\r
1363                 else\r
1364                 {\r
1365                     int i2 = (curChar & 0xff) >> 6;\r
1366                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
1367                 MatchLoop1: \r
1368                     do \r
1369                     {\r
1370                         switch (jjstateSet[--i])\r
1371                         {\r
1372                                                         \r
1373                             case 1: \r
1374                             case 0: \r
1375                                 if ((jjbitVec0[i2] & l2) == 0L)\r
1376                                     break;\r
1377                                 if (kind > 26)\r
1378                                     kind = 26;\r
1379                                 jjCheckNAdd(0);\r
1380                                 break;\r
1381                                                         \r
1382                             default:  break;\r
1383                                                         \r
1384                         }\r
1385                     }\r
1386                     while (i != startsAt);\r
1387                 }\r
1388                 if (kind != 0x7fffffff)\r
1389                 {\r
1390                     jjmatchedKind = kind;\r
1391                     jjmatchedPos = curPos;\r
1392                     kind = 0x7fffffff;\r
1393                 }\r
1394                 ++curPos;\r
1395                 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))\r
1396                     return curPos;\r
1397                 try\r
1398                 {\r
1399                     curChar = input_stream.ReadChar();\r
1400                 }\r
1401                 catch (System.IO.IOException e)\r
1402                 {\r
1403                     return curPos;\r
1404                 }\r
1405             }\r
1406         }\r
1407         private int jjMoveStringLiteralDfa0_1()\r
1408         {\r
1409             return jjMoveNfa_1(1, 0);\r
1410         }\r
1411         private int jjMoveNfa_1(int startState, int curPos)\r
1412         {\r
1413             int[] nextStates;\r
1414             int startsAt = 0;\r
1415             jjnewStateCnt = 12;\r
1416             int i = 1;\r
1417             jjstateSet[0] = startState;\r
1418             int j, kind = 0x7fffffff;\r
1419             for (; ; )\r
1420             {\r
1421                 if (++jjround == 0x7fffffff)\r
1422                     ReInitRounds();\r
1423                 if (curChar < 64)\r
1424                 {\r
1425                     ulong l = ((ulong) 1L) << curChar;\r\r
1426 MatchLoop1: \r
1427                     do \r
1428                     {\r
1429                         switch (jjstateSet[--i])\r
1430                         {\r
1431                                                         \r
1432                             case 1: \r
1433                                 if ((0xafffffffffffffffL & l) != 0L)\r
1434                                 {\r
1435                                     if (kind > 13)\r
1436                                         kind = 13;\r
1437                                     jjCheckNAdd(0);\r
1438                                 }\r
1439                                 else if ((0x5000000000000000L & l) != 0L)\r
1440                                 {\r
1441                                     if (kind > 13)\r
1442                                         kind = 13;\r
1443                                 }\r
1444                                 if (curChar == 60)\r
1445                                     jjstateSet[jjnewStateCnt++] = 10;\r
1446                                 break;\r
1447                                                         \r
1448                             case 0: \r
1449                                 if ((0xafffffffffffffffL & l) == 0L)\r
1450                                     break;\r
1451                                 if (kind > 13)\r
1452                                     kind = 13;\r
1453                                 jjCheckNAdd(0);\r
1454                                 break;\r
1455                                                         \r
1456                             case 3: \r
1457                                 if ((0xafffffffffffffffL & l) != 0L)\r
1458                                     jjAddStates(19, 20);\r
1459                                 break;\r
1460                                                         \r
1461                             case 4: \r
1462                                 if (curChar == 62 && kind > 14)\r
1463                                     kind = 14;\r
1464                                 break;\r
1465                                                         \r
1466                             case 10: \r
1467                                 if (curChar == 47)\r
1468                                     jjstateSet[jjnewStateCnt++] = 9;\r
1469                                 break;\r
1470                                                         \r
1471                             case 11: \r
1472                                 if (curChar == 60)\r
1473                                     jjstateSet[jjnewStateCnt++] = 10;\r
1474                                 break;\r
1475                                                         \r
1476                             default:  break;\r
1477                                                         \r
1478                         }\r
1479                     }\r
1480                     while (i != startsAt);\r
1481                 }\r
1482                 else if (curChar < 128)\r
1483                 {\r
1484                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
1485 MatchLoop1: \r
1486                     do \r
1487                     {\r
1488                         switch (jjstateSet[--i])\r
1489                         {\r
1490                                                         \r
1491                             case 1: \r
1492                             case 0: \r
1493                                 if (kind > 13)\r
1494                                     kind = 13;\r
1495                                 jjCheckNAdd(0);\r
1496                                 break;\r
1497                                                         \r
1498                             case 2: \r
1499                                 if (curChar == 116)\r
1500                                     jjCheckNAddTwoStates(3, 4);\r
1501                                 break;\r
1502                                                         \r
1503                             case 3: \r
1504                                 jjCheckNAddTwoStates(3, 4);\r
1505                                 break;\r
1506                                                         \r
1507                             case 5: \r
1508                                 if (curChar == 112)\r
1509                                     jjstateSet[jjnewStateCnt++] = 2;\r
1510                                 break;\r
1511                                                         \r
1512                             case 6: \r
1513                                 if (curChar == 105)\r
1514                                     jjstateSet[jjnewStateCnt++] = 5;\r
1515                                 break;\r
1516                                                         \r
1517                             case 7: \r
1518                                 if (curChar == 114)\r
1519                                     jjstateSet[jjnewStateCnt++] = 6;\r
1520                                 break;\r
1521                                                         \r
1522                             case 8: \r
1523                                 if (curChar == 99)\r
1524                                     jjstateSet[jjnewStateCnt++] = 7;\r
1525                                 break;\r
1526                                                         \r
1527                             case 9: \r
1528                                 if (curChar == 115)\r
1529                                     jjstateSet[jjnewStateCnt++] = 8;\r
1530                                 break;\r
1531                                                         \r
1532                             default:  break;\r
1533                                                         \r
1534                         }\r
1535                     }\r
1536                     while (i != startsAt);\r
1537                 }\r
1538                 else\r
1539                 {\r
1540                     int i2 = (curChar & 0xff) >> 6;\r
1541                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
1542                 MatchLoop1: \r
1543                     do \r
1544                     {\r
1545                         switch (jjstateSet[--i])\r
1546                         {\r
1547                                                         \r
1548                             case 1: \r
1549                             case 0: \r
1550                                 if ((jjbitVec0[i2] & l2) == 0L)\r
1551                                     break;\r
1552                                 if (kind > 13)\r
1553                                     kind = 13;\r
1554                                 jjCheckNAdd(0);\r
1555                                 break;\r
1556                                                         \r
1557                             case 3: \r
1558                                 if ((jjbitVec0[i2] & l2) != 0L)\r
1559                                     jjAddStates(19, 20);\r
1560                                 break;\r
1561                                                         \r
1562                             default:  break;\r
1563                                                         \r
1564                         }\r
1565                     }\r
1566                     while (i != startsAt);\r
1567                 }\r
1568                 if (kind != 0x7fffffff)\r
1569                 {\r
1570                     jjmatchedKind = kind;\r
1571                     jjmatchedPos = curPos;\r
1572                     kind = 0x7fffffff;\r
1573                 }\r
1574                 ++curPos;\r
1575                 if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))\r
1576                     return curPos;\r
1577                 try\r
1578                 {\r
1579                     curChar = input_stream.ReadChar();\r
1580                 }\r
1581                 catch (System.IO.IOException e)\r
1582                 {\r
1583                     return curPos;\r
1584                 }\r
1585             }\r
1586         }\r
1587         private int jjStopStringLiteralDfa_2(int pos, long active0)\r
1588         {\r
1589             switch (pos)\r
1590             {\r
1591                                 \r
1592                 default: \r
1593                     return - 1;\r
1594                                 \r
1595             }\r
1596         }\r
1597         private int jjStartNfa_2(int pos, long active0)\r
1598         {\r
1599             return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);\r
1600         }\r
1601         private int jjStartNfaWithStates_2(int pos, int kind, int state)\r
1602         {\r
1603             jjmatchedKind = kind;\r
1604             jjmatchedPos = pos;\r
1605             try\r
1606             {\r
1607                 curChar = input_stream.ReadChar();\r
1608             }\r
1609             catch (System.IO.IOException e)\r
1610             {\r
1611                 return pos + 1;\r
1612             }\r
1613             return jjMoveNfa_2(state, pos + 1);\r
1614         }\r
1615         private int jjMoveStringLiteralDfa0_2()\r
1616         {\r
1617             switch (curChar)\r
1618             {\r
1619                                 \r
1620                 case (char) (34): \r
1621                     return jjStopAtPos(0, 20);\r
1622                                 \r
1623                 case (char) (39): \r
1624                     return jjStopAtPos(0, 19);\r
1625                                 \r
1626                 case (char) (61): \r
1627                     return jjStartNfaWithStates_2(0, 16, 3);\r
1628                                 \r
1629                 default: \r
1630                     return jjMoveNfa_2(0, 0);\r
1631                                 \r
1632             }\r
1633         }\r
1634         private int jjMoveNfa_2(int startState, int curPos)\r
1635         {\r
1636             int[] nextStates;\r
1637             int startsAt = 0;\r
1638             jjnewStateCnt = 6;\r
1639             int i = 1;\r
1640             jjstateSet[0] = startState;\r
1641             int j, kind = 0x7fffffff;\r
1642             for (; ; )\r
1643             {\r
1644                 if (++jjround == 0x7fffffff)\r
1645                     ReInitRounds();\r
1646                 if (curChar < 64)\r
1647                 {\r
1648                     ulong l = ((ulong) 1L) << curChar;\r\r
1649 MatchLoop1: \r
1650                     do \r
1651                     {\r
1652                         switch (jjstateSet[--i])\r
1653                         {\r
1654                                                         \r
1655                             case 0: \r
1656                                 if ((0x9fffff7affffd9ffL & l) != 0L)\r
1657                                 {\r
1658                                     if (kind > 15)\r
1659                                         kind = 15;\r
1660                                     jjCheckNAdd(1);\r
1661                                 }\r
1662                                 else if ((0x100002600L & l) != 0L)\r
1663                                 {\r
1664                                     if (kind > 21)\r
1665                                         kind = 21;\r
1666                                     jjCheckNAdd(5);\r
1667                                 }\r
1668                                 else if (curChar == 61)\r
1669                                     jjstateSet[jjnewStateCnt++] = 3;\r
1670                                 else if (curChar == 62)\r
1671                                 {\r
1672                                     if (kind > 17)\r
1673                                         kind = 17;\r
1674                                 }\r
1675                                 break;\r
1676                                                         \r
1677                             case 1: \r
1678                                 if ((0x9ffffffeffffd9ffL & l) == 0L)\r
1679                                     break;\r
1680                                 if (kind > 15)\r
1681                                     kind = 15;\r
1682                                 jjCheckNAdd(1);\r
1683                                 break;\r
1684                                                         \r
1685                             case 2: \r
1686                             case 3: \r
1687                                 if (curChar == 62 && kind > 17)\r
1688                                     kind = 17;\r
1689                                 break;\r
1690                                                         \r
1691                             case 4: \r
1692                                 if (curChar == 61)\r
1693                                     jjstateSet[jjnewStateCnt++] = 3;\r
1694                                 break;\r
1695                                                         \r
1696                             case 5: \r
1697                                 if ((0x100002600L & l) == 0L)\r
1698                                     break;\r
1699                                 kind = 21;\r
1700                                 jjCheckNAdd(5);\r
1701                                 break;\r
1702                                                         \r
1703                             default:  break;\r
1704                                                         \r
1705                         }\r
1706                     }\r
1707                     while (i != startsAt);\r
1708                 }\r
1709                 else if (curChar < 128)\r
1710                 {\r
1711                     ulong l = ((ulong) 1L) << (curChar & 63);\r\r
1712 MatchLoop1: \r
1713                     do \r
1714                     {\r
1715                         switch (jjstateSet[--i])\r
1716                         {\r
1717                                                         \r
1718                             case 0: \r
1719                             case 1: \r
1720                                 if (kind > 15)\r
1721                                     kind = 15;\r
1722                                 jjCheckNAdd(1);\r
1723                                 break;\r
1724                                                         \r
1725                             default:  break;\r
1726                                                         \r
1727                         }\r
1728                     }\r
1729                     while (i != startsAt);\r
1730                 }\r
1731                 else\r
1732                 {\r
1733                     int i2 = (curChar & 0xff) >> 6;\r
1734                     ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
1735                 MatchLoop1: \r
1736                     do \r
1737                     {\r
1738                         switch (jjstateSet[--i])\r
1739                         {\r
1740                                                         \r
1741                             case 0: \r
1742                             case 1: \r
1743                                 if ((jjbitVec0[i2] & l2) == 0L)\r
1744                                     break;\r
1745                                 if (kind > 15)\r
1746                                     kind = 15;\r
1747                                 jjCheckNAdd(1);\r
1748                                 break;\r
1749                                                         \r
1750                             default:  break;\r
1751                                                         \r
1752                         }\r
1753                     }\r
1754                     while (i != startsAt);\r
1755                 }\r
1756                 if (kind != 0x7fffffff)\r
1757                 {\r
1758                     jjmatchedKind = kind;\r
1759                     jjmatchedPos = curPos;\r
1760                     kind = 0x7fffffff;\r
1761                 }\r
1762                 ++curPos;\r
1763                 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))\r
1764                     return curPos;\r
1765                 try\r
1766                 {\r
1767                     curChar = input_stream.ReadChar();\r
1768                 }\r
1769                 catch (System.IO.IOException e)\r
1770                 {\r
1771                     return curPos;\r
1772                 }\r
1773             }\r
1774         }\r
1775         internal static readonly int[] jjnextStates = new int[]{17, 18, 21, 12, 14, 5, 8, 0, 4, 6, 0, 4, 6, 5, 0, 4, 6, 12, 13, 3, 4};\r
1776         public static readonly System.String[] jjstrLiteralImages = new System.String[]{"", "\x003C\x0073\x0063\x0072\x0069\x0070\x0074", null, null, "\x003C\x0021\x002D\x002D", "\x003C\x0021", null, null, null, null, null, null, null, null, null, null, "\x003D", null, null, "\x0027", "\x0022", null, null, null, null, null, null, "\x002D\x002D\x003E", null, "\x003E"};\r
1777         public static readonly System.String[] lexStateNames = new System.String[]{"DEFAULT", "WithinScript", "WithinTag", "AfterEquals", "WithinQuote1", "WithinQuote2", "WithinComment1", "WithinComment2"};\r
1778         public static readonly int[] jjnewLexState = new int[]{-1, 1, 2, 2, 6, 7, -1, -1, - 1, -1, -1, -1, -1, -1, 0, -1, 3, 0, 2, 4, 5, -1, -1, 2, -1, 2, -1, 0, -1, 0};\r
1779         internal static readonly long[] jjtoToken = new long[]{0x3fdff67fL};\r
1780         internal static readonly long[] jjtoSkip = new long[]{0x200000L};\r
1781         protected internal SimpleCharStream input_stream;\r
1782         private uint[] jjrounds = new uint[25];\r
1783         private int[] jjstateSet = new int[50];\r
1784         protected internal char curChar;\r
1785         public HTMLParserTokenManager(SimpleCharStream stream)\r
1786         {\r
1787             InitBlock();\r
1788             if (SimpleCharStream.staticFlag)\r
1789                 throw new System.ApplicationException("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");\r
1790             input_stream = stream;\r
1791         }\r
1792         public HTMLParserTokenManager(SimpleCharStream stream, int lexState):this(stream)\r
1793         {\r
1794             SwitchTo(lexState);\r
1795         }\r
1796         public virtual void  ReInit(SimpleCharStream stream)\r
1797         {\r
1798             jjmatchedPos = jjnewStateCnt = 0;\r
1799             curLexState = defaultLexState;\r
1800             input_stream = stream;\r
1801             ReInitRounds();\r
1802         }\r
1803         private void  ReInitRounds()\r
1804         {\r
1805             int i;\r
1806             jjround = 0x80000001;\r
1807             for (i = 25; i-- > 0; )\r
1808                 jjrounds[i] = 0x80000000;\r
1809         }\r
1810         public virtual void  ReInit(SimpleCharStream stream, int lexState)\r
1811         {\r
1812             ReInit(stream);\r
1813             SwitchTo(lexState);\r
1814         }\r
1815         public virtual void  SwitchTo(int lexState)\r
1816         {\r
1817             if (lexState >= 8 || lexState < 0)\r
1818                 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);\r
1819             else\r
1820                 curLexState = lexState;\r
1821         }\r
1822                 \r
1823         protected internal virtual Token jjFillToken()\r
1824         {\r
1825             Token t = Token.newToken(jjmatchedKind);\r
1826             t.kind = jjmatchedKind;\r
1827             System.String im = jjstrLiteralImages[jjmatchedKind];\r
1828             t.image = (im == null)?input_stream.GetImage():im;\r
1829             t.beginLine = input_stream.GetBeginLine();\r
1830             t.beginColumn = input_stream.GetBeginColumn();\r
1831             t.endLine = input_stream.GetEndLine();\r
1832             t.endColumn = input_stream.GetEndColumn();\r
1833             return t;\r
1834         }\r
1835                 \r
1836         internal int curLexState = 0;\r
1837         internal int defaultLexState = 0;\r
1838         internal int jjnewStateCnt;\r
1839         internal uint jjround;\r
1840         internal int jjmatchedPos;\r
1841         internal int jjmatchedKind;\r
1842                 \r
1843         public virtual Token GetNextToken()\r
1844         {\r
1845             int kind;\r
1846             Token specialToken = null;\r
1847             Token matchedToken;\r
1848             int curPos = 0;\r
1849                         \r
1850             for (; ; )\r
1851             {\r
1852                 try\r
1853                 {\r
1854                     curChar = input_stream.BeginToken();\r
1855                 }\r
1856                 catch (System.IO.IOException e)\r
1857                 {\r
1858                     jjmatchedKind = 0;\r
1859                     matchedToken = jjFillToken();\r
1860                     return matchedToken;\r
1861                 }\r
1862                                 \r
1863                 switch (curLexState)\r
1864                 {\r
1865                                         \r
1866                     case 0: \r
1867                         jjmatchedKind = 0x7fffffff;\r
1868                         jjmatchedPos = 0;\r
1869                         curPos = jjMoveStringLiteralDfa0_0();\r
1870                         if (jjmatchedPos == 0 && jjmatchedKind > 12)\r
1871                         {\r
1872                             jjmatchedKind = 12;\r
1873                         }\r
1874                         break;\r
1875                                         \r
1876                     case 1: \r
1877                         jjmatchedKind = 0x7fffffff;\r
1878                         jjmatchedPos = 0;\r
1879                         curPos = jjMoveStringLiteralDfa0_1();\r
1880                         break;\r
1881                                         \r
1882                     case 2: \r
1883                         jjmatchedKind = 0x7fffffff;\r
1884                         jjmatchedPos = 0;\r
1885                         curPos = jjMoveStringLiteralDfa0_2();\r
1886                         break;\r
1887                                         \r
1888                     case 3: \r
1889                         jjmatchedKind = 0x7fffffff;\r
1890                         jjmatchedPos = 0;\r
1891                         curPos = jjMoveStringLiteralDfa0_3();\r
1892                         break;\r
1893                                         \r
1894                     case 4: \r
1895                         jjmatchedKind = 0x7fffffff;\r
1896                         jjmatchedPos = 0;\r
1897                         curPos = jjMoveStringLiteralDfa0_4();\r
1898                         break;\r
1899                                         \r
1900                     case 5: \r
1901                         jjmatchedKind = 0x7fffffff;\r
1902                         jjmatchedPos = 0;\r
1903                         curPos = jjMoveStringLiteralDfa0_5();\r
1904                         break;\r
1905                                         \r
1906                     case 6: \r
1907                         jjmatchedKind = 0x7fffffff;\r
1908                         jjmatchedPos = 0;\r
1909                         curPos = jjMoveStringLiteralDfa0_6();\r
1910                         break;\r
1911                                         \r
1912                     case 7: \r
1913                         jjmatchedKind = 0x7fffffff;\r
1914                         jjmatchedPos = 0;\r
1915                         curPos = jjMoveStringLiteralDfa0_7();\r
1916                         break;\r
1917                 }\r
1918                 if (jjmatchedKind != 0x7fffffff)\r
1919                 {\r
1920                     if (jjmatchedPos + 1 < curPos)\r
1921                         input_stream.Backup(curPos - jjmatchedPos - 1);\r
1922                     if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)\r
1923                     {\r
1924                         matchedToken = jjFillToken();\r
1925                         if (jjnewLexState[jjmatchedKind] != - 1)\r
1926                             curLexState = jjnewLexState[jjmatchedKind];\r
1927                         return matchedToken;\r
1928                     }\r
1929                     else\r
1930                     {\r
1931                         if (jjnewLexState[jjmatchedKind] != - 1)\r
1932                             curLexState = jjnewLexState[jjmatchedKind];\r
1933                         goto EOFLoop;\r
1934                     }\r
1935                 }\r
1936                 int error_line = input_stream.GetEndLine();\r
1937                 int error_column = input_stream.GetEndColumn();\r
1938                 System.String error_after = null;\r
1939                 bool EOFSeen = false;\r
1940                 try\r
1941                 {\r
1942                     input_stream.ReadChar(); input_stream.Backup(1);\r
1943                 }\r
1944                 catch (System.IO.IOException e1)\r
1945                 {\r
1946                     EOFSeen = true;\r
1947                     error_after = curPos <= 1?"":input_stream.GetImage();\r
1948                     if (curChar == '\n' || curChar == '\r')\r
1949                     {\r
1950                         error_line++;\r
1951                         error_column = 0;\r
1952                     }\r
1953                     else\r
1954                         error_column++;\r
1955                 }\r
1956                 if (!EOFSeen)\r
1957                 {\r
1958                     input_stream.Backup(1);\r
1959                     error_after = curPos <= 1?"":input_stream.GetImage();\r
1960                 }\r
1961                 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);\r
1962 \r
1963             EOFLoop: ;\r
1964             }\r
1965         }\r
1966     }\r
1967 }