mcs/tools/monodoc/Lucene.Net/Lucene.Net/Analysis/Standard/StandardTokenizerTokenManager.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 /* Generated By:JavaCC: Do not edit this line. StandardTokenizerTokenManager.java */\r
  17 using System;\r
  18 namespace Monodoc.Lucene.Net.Analysis.Standard\r
  19 {\r
  20         \r
  21         public class StandardTokenizerTokenManager : StandardTokenizerConstants\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 JjMoveStringLiteralDfa0_0()\r
  36                 {\r
  37                         return JjMoveNfa_0(0, 0);\r
  38                 }\r
  39                 private void  JjCheckNAdd(int state)\r
  40                 {\r
  41                         if (jjrounds[state] != jjround)\r
  42                         {\r
  43                                 jjstateSet[jjnewStateCnt++] = state;\r
  44                                 jjrounds[state] = jjround;\r
  45                         }\r
  46                 }\r
  47                 private void  JjAddStates(int start, int end)\r
  48                 {\r
  49                         do \r
  50                         {\r
  51                                 jjstateSet[jjnewStateCnt++] = jjnextStates[start];\r
  52                         }\r
  53                         while (start++ != end);\r
  54                 }\r
  55                 private void  JjCheckNAddTwoStates(int state1, int state2)\r
  56                 {\r
  57                         JjCheckNAdd(state1);\r
  58                         JjCheckNAdd(state2);\r
  59                 }\r
  60                 private void  JjCheckNAddStates(int start, int end)\r
  61                 {\r
  62                         do \r
  63                         {\r
  64                                 JjCheckNAdd(jjnextStates[start]);\r
  65                         }\r
  66                         while (start++ != end);\r
  67                 }\r
  68                 private void  JjCheckNAddStates(int start)\r
  69                 {\r
  70                         JjCheckNAdd(jjnextStates[start]);\r
  71                         JjCheckNAdd(jjnextStates[start + 1]);\r
  72                 }\r
  73                 internal static readonly ulong[] jjbitVec0 = new ulong[]{0x1ff0000000000000L, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L};\r
  74                 internal static readonly ulong[] jjbitVec2 = new ulong[]{0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL};\r
  75                 internal static readonly ulong[] jjbitVec3 = new ulong[]{0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L};\r
  76                 internal static readonly ulong[] jjbitVec4 = new ulong[]{0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L};\r
  77                 internal static readonly ulong[] jjbitVec5 = new ulong[]{0x3fffffffffffL, 0x0L, 0x0L, 0x0L};\r
  78                 internal static readonly ulong[] jjbitVec6 = new ulong[]{0x1600L, 0x0L, 0x0L, 0x0L};\r
  79                 internal static readonly ulong[] jjbitVec7 = new ulong[]{0x0L, 0xffc000000000L, 0x0L, 0xffc000000000L};\r
  80                 internal static readonly ulong[] jjbitVec8 = new ulong[]{0x0L, 0x3ff00000000L, 0x0L, 0x3ff000000000000L};\r
  81                 internal static readonly ulong[] jjbitVec9 = new ulong[]{0x0L, 0xffc000000000L, 0x0L, 0xff8000000000L};\r
  82                 internal static readonly ulong[] jjbitVec10 = new ulong[]{0x0L, 0xffc000000000L, 0x0L, 0x0L};\r
  83                 internal static readonly ulong[] jjbitVec11 = new ulong[]{0x0L, 0x3ff0000L, 0x0L, 0x3ff0000L};\r
  84                 internal static readonly ulong[] jjbitVec12 = new ulong[]{0x0L, 0x3ffL, 0x0L, 0x0L};\r
  85                 internal static readonly ulong[] jjbitVec13 = new ulong[]{0xfffffffeL, 0x0L, 0x0L, 0x0L};\r
  86                 internal static readonly ulong[] jjbitVec14 = new ulong[]{0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL};\r
  87                 private int JjMoveNfa_0(int startState, int curPos)\r
  88                 {\r
  89                         int startsAt = 0;\r
  90                         jjnewStateCnt = 73;\r
  91                         int ii = 1;\r
  92                         jjstateSet[0] = startState;\r
  93                         int kind = 0x7fffffff;\r
  94                         for (; ; )\r
  95                         {\r
  96                                 if (++jjround == 0x7fffffff)\r
  97                                         ReInitRounds();\r
  98                                 if (curChar < 64)\r
  99                                 {\r
 100                                         ulong l = ((ulong) 1L) << curChar;\r\r
 101                                         do \r
 102                                         {\r
 103                                                 switch (jjstateSet[--ii])\r
 104                                                 {\r
 105                                                         \r
 106                                                         case 0: \r
 107                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 108                                                                 {\r
 109                                                                         if (kind > 1)\r
 110                                                                                 kind = 1;\r
 111                                                                         JjCheckNAddStates(0, 17);\r
 112                                                                 }\r
 113                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 114                                                                         JjCheckNAddStates(18, 23);\r
 115                                                                 break;\r
 116                                                         \r
 117                                                         case 1: \r
 118                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 119                                                                         JjCheckNAddStates(18, 23);\r
 120                                                                 break;\r
 121                                                         \r
 122                                                         case 2: \r
 123                                                         case 39: \r
 124                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 125                                                                         JjCheckNAddTwoStates(2, 3);\r
 126                                                                 break;\r
 127                                                         \r
 128                                                         case 3: \r
 129                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 130                                                                         JjCheckNAdd(4);\r
 131                                                                 break;\r
 132                                                         \r
 133                                                         case 4: \r
 134                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 135                                                                         break;\r
 136                                                                 if (kind > 7)\r
 137                                                                         kind = 7;\r
 138                                                                 JjCheckNAdd(4);\r
 139                                                                 break;\r
 140                                                         \r
 141                                                         case 5: \r
 142                                                         case 48: \r
 143                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 144                                                                         JjCheckNAddTwoStates(5, 6);\r
 145                                                                 break;\r
 146                                                         \r
 147                                                         case 6: \r
 148                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 149                                                                         JjCheckNAdd(7);\r
 150                                                                 break;\r
 151                                                         \r
 152                                                         case 7: \r
 153                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 154                                                                         JjCheckNAddTwoStates(7, 8);\r
 155                                                                 break;\r
 156                                                         \r
 157                                                         case 8: \r
 158                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 159                                                                         JjCheckNAddTwoStates(9, 10);\r
 160                                                                 break;\r
 161                                                         \r
 162                                                         case 9: \r
 163                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 164                                                                         JjCheckNAddTwoStates(9, 10);\r
 165                                                                 break;\r
 166                                                         \r
 167                                                         case 10: \r
 168                                                         case 11: \r
 169                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 170                                                                         break;\r
 171                                                                 if (kind > 7)\r
 172                                                                         kind = 7;\r
 173                                                                 JjCheckNAddTwoStates(6, 11);\r
 174                                                                 break;\r
 175                                                         \r
 176                                                         case 12: \r
 177                                                         case 61: \r
 178                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 179                                                                         JjCheckNAddTwoStates(12, 13);\r
 180                                                                 break;\r
 181                                                         \r
 182                                                         case 13: \r
 183                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 184                                                                         JjCheckNAdd(14);\r
 185                                                                 break;\r
 186                                                         \r
 187                                                         case 14: \r
 188                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 189                                                                         JjCheckNAddTwoStates(14, 15);\r
 190                                                                 break;\r
 191                                                         \r
 192                                                         case 15: \r
 193                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 194                                                                         JjCheckNAddTwoStates(16, 17);\r
 195                                                                 break;\r
 196                                                         \r
 197                                                         case 16: \r
 198                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 199                                                                         JjCheckNAddTwoStates(16, 17);\r
 200                                                                 break;\r
 201                                                         \r
 202                                                         case 17: \r
 203                                                         case 18: \r
 204                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 205                                                                         JjCheckNAddTwoStates(18, 19);\r
 206                                                                 break;\r
 207                                                         \r
 208                                                         case 19: \r
 209                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 210                                                                         JjCheckNAdd(20);\r
 211                                                                 break;\r
 212                                                         \r
 213                                                         case 20: \r
 214                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 215                                                                         break;\r
 216                                                                 if (kind > 7)\r
 217                                                                         kind = 7;\r
 218                                                                 JjCheckNAddTwoStates(15, 20);\r
 219                                                                 break;\r
 220                                                         \r
 221                                                         case 21: \r
 222                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 223                                                                         break;\r
 224                                                                 if (kind > 1)\r
 225                                                                         kind = 1;\r
 226                                                                 JjCheckNAddStates(0, 17);\r
 227                                                                 break;\r
 228                                                         \r
 229                                                         case 22: \r
 230                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 231                                                                         break;\r
 232                                                                 if (kind > 1)\r
 233                                                                         kind = 1;\r
 234                                                                 JjCheckNAdd(22);\r
 235                                                                 break;\r
 236                                                         \r
 237                                                         case 23: \r
 238                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 239                                                                         JjCheckNAddStates(24, 26);\r
 240                                                                 break;\r
 241                                                         \r
 242                                                         case 24: \r
 243                                                                 if ((0x600000000000L & l) != (ulong) 0L)\r
 244                                                                         JjCheckNAdd(25);\r
 245                                                                 break;\r
 246                                                         \r
 247                                                         case 25: \r
 248                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 249                                                                         JjCheckNAddStates(27, 29);\r
 250                                                                 break;\r
 251                                                         \r
 252                                                         case 27: \r
 253                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 254                                                                         JjCheckNAddTwoStates(27, 28);\r
 255                                                                 break;\r
 256                                                         \r
 257                                                         case 28: \r
 258                                                                 if ((0x600000000000L & l) != (ulong) 0L)\r
 259                                                                         JjCheckNAdd(29);\r
 260                                                                 break;\r
 261                                                         \r
 262                                                         case 29: \r
 263                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 264                                                                         break;\r
 265                                                                 if (kind > 5)\r
 266                                                                         kind = 5;\r
 267                                                                 JjCheckNAddTwoStates(28, 29);\r
 268                                                                 break;\r
 269                                                         \r
 270                                                         case 30: \r
 271                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 272                                                                         JjCheckNAddTwoStates(30, 31);\r
 273                                                                 break;\r
 274                                                         \r
 275                                                         case 31: \r
 276                                                                 if (curChar == 46)\r
 277                                                                         JjCheckNAdd(32);\r
 278                                                                 break;\r
 279                                                         \r
 280                                                         case 32: \r
 281                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 282                                                                         break;\r
 283                                                                 if (kind > 6)\r
 284                                                                         kind = 6;\r
 285                                                                 JjCheckNAddTwoStates(31, 32);\r
 286                                                                 break;\r
 287                                                         \r
 288                                                         case 33: \r
 289                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 290                                                                         JjCheckNAddTwoStates(33, 34);\r
 291                                                                 break;\r
 292                                                         \r
 293                                                         case 34: \r
 294                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 295                                                                         JjCheckNAddTwoStates(35, 36);\r
 296                                                                 break;\r
 297                                                         \r
 298                                                         case 35: \r
 299                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 300                                                                         JjCheckNAddTwoStates(35, 36);\r
 301                                                                 break;\r
 302                                                         \r
 303                                                         case 36: \r
 304                                                         case 37: \r
 305                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 306                                                                         break;\r
 307                                                                 if (kind > 7)\r
 308                                                                         kind = 7;\r
 309                                                                 JjCheckNAdd(37);\r
 310                                                                 break;\r
 311                                                         \r
 312                                                         case 38: \r
 313                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 314                                                                         JjCheckNAddTwoStates(38, 39);\r
 315                                                                 break;\r
 316                                                         \r
 317                                                         case 40: \r
 318                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 319                                                                         JjCheckNAddTwoStates(40, 41);\r
 320                                                                 break;\r
 321                                                         \r
 322                                                         case 41: \r
 323                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 324                                                                         JjCheckNAddTwoStates(42, 43);\r
 325                                                                 break;\r
 326                                                         \r
 327                                                         case 42: \r
 328                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 329                                                                         JjCheckNAddTwoStates(42, 43);\r
 330                                                                 break;\r
 331                                                         \r
 332                                                         case 43: \r
 333                                                         case 44: \r
 334                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 335                                                                         JjCheckNAddTwoStates(44, 45);\r
 336                                                                 break;\r
 337                                                         \r
 338                                                         case 45: \r
 339                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 340                                                                         JjCheckNAdd(46);\r
 341                                                                 break;\r
 342                                                         \r
 343                                                         case 46: \r
 344                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 345                                                                         break;\r
 346                                                                 if (kind > 7)\r
 347                                                                         kind = 7;\r
 348                                                                 JjCheckNAddTwoStates(41, 46);\r
 349                                                                 break;\r
 350                                                         \r
 351                                                         case 47: \r
 352                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 353                                                                         JjCheckNAddTwoStates(47, 48);\r
 354                                                                 break;\r
 355                                                         \r
 356                                                         case 49: \r
 357                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 358                                                                         JjCheckNAddTwoStates(49, 50);\r
 359                                                                 break;\r
 360                                                         \r
 361                                                         case 50: \r
 362                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 363                                                                         JjCheckNAddTwoStates(51, 52);\r
 364                                                                 break;\r
 365                                                         \r
 366                                                         case 51: \r
 367                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 368                                                                         JjCheckNAddTwoStates(51, 52);\r
 369                                                                 break;\r
 370                                                         \r
 371                                                         case 52: \r
 372                                                         case 53: \r
 373                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 374                                                                         JjCheckNAddTwoStates(53, 54);\r
 375                                                                 break;\r
 376                                                         \r
 377                                                         case 54: \r
 378                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 379                                                                         JjCheckNAdd(55);\r
 380                                                                 break;\r
 381                                                         \r
 382                                                         case 55: \r
 383                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 384                                                                         JjCheckNAddTwoStates(55, 56);\r
 385                                                                 break;\r
 386                                                         \r
 387                                                         case 56: \r
 388                                                                 if ((0xf00000000000L & l) != (ulong) 0L)\r
 389                                                                         JjCheckNAddTwoStates(57, 58);\r
 390                                                                 break;\r
 391                                                         \r
 392                                                         case 57: \r
 393                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 394                                                                         JjCheckNAddTwoStates(57, 58);\r
 395                                                                 break;\r
 396                                                         \r
 397                                                         case 58: \r
 398                                                         case 59: \r
 399                                                                 if ((0x3ff000000000000L & l) == (ulong) 0L)\r
 400                                                                         break;\r
 401                                                                 if (kind > 7)\r
 402                                                                         kind = 7;\r
 403                                                                 JjCheckNAddTwoStates(54, 59);\r
 404                                                                 break;\r
 405                                                         \r
 406                                                         case 60: \r
 407                                                                 if ((0x3ff000000000000L & l) != (ulong) 0L)\r
 408                                                                         JjCheckNAddTwoStates(60, 61);\r
 409                                                                 break;\r
 410                                                         \r
 411                                                         case 64: \r
 412                                                                 if (curChar == 39)\r
 413                                                                         jjstateSet[jjnewStateCnt++] = 65;\r
 414                                                                 break;\r
 415                                                         \r
 416                                                         case 67: \r
 417                                                                 if (curChar == 46)\r
 418                                                                         JjCheckNAdd(68);\r
 419                                                                 break;\r
 420                                                         \r
 421                                                         case 69: \r
 422                                                                 if (curChar != 46)\r
 423                                                                         break;\r
 424                                                                 if (kind > 3)\r
 425                                                                         kind = 3;\r
 426                                                                 JjCheckNAdd(68);\r
 427                                                                 break;\r
 428                                                         \r
 429                                                         case 71: \r
 430                                                                 if (curChar == 38)\r
 431                                                                         jjstateSet[jjnewStateCnt++] = 72;\r
 432                                                                 break;\r
 433                                                         \r
 434                                                         default:  break;\r
 435                                                         \r
 436                                                 }\r
 437                                         }\r
 438                                         while (ii != startsAt);\r
 439                                 }\r
 440                                 else if (curChar < 128)\r
 441                                 {\r
 442                                         ulong l = ((ulong) 1L) << (curChar & 63);\r\r
 443                                         do \r
 444                                         {\r
 445                                                 switch (jjstateSet[--ii])\r
 446                                                 {\r
 447                                                         \r
 448                                                         case 0: \r
 449                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 450                                                                         JjCheckNAddStates(30, 35);\r
 451                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 452                                                                 {\r
 453                                                                         if (kind > 1)\r
 454                                                                                 kind = 1;\r
 455                                                                         JjCheckNAddStates(0, 17);\r
 456                                                                 }\r
 457                                                                 break;\r
 458                                                         \r
 459                                                         case 2: \r
 460                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 461                                                                         JjAddStates(36, 37);\r
 462                                                                 break;\r
 463                                                         \r
 464                                                         case 3: \r
 465                                                                 if (curChar == 95)\r
 466                                                                         JjCheckNAdd(4);\r
 467                                                                 break;\r
 468                                                         \r
 469                                                         case 4: \r
 470                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 471                                                                         break;\r
 472                                                                 if (kind > 7)\r
 473                                                                         kind = 7;\r
 474                                                                 JjCheckNAdd(4);\r
 475                                                                 break;\r
 476                                                         \r
 477                                                         case 5: \r
 478                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 479                                                                         JjCheckNAddTwoStates(5, 6);\r
 480                                                                 break;\r
 481                                                         \r
 482                                                         case 6: \r
 483                                                                 if (curChar == 95)\r
 484                                                                         JjCheckNAdd(7);\r
 485                                                                 break;\r
 486                                                         \r
 487                                                         case 7: \r
 488                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 489                                                                         JjCheckNAddTwoStates(7, 8);\r
 490                                                                 break;\r
 491                                                         \r
 492                                                         case 8: \r
 493                                                                 if (curChar == 95)\r
 494                                                                         JjCheckNAddTwoStates(9, 10);\r
 495                                                                 break;\r
 496                                                         \r
 497                                                         case 9: \r
 498                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 499                                                                         JjCheckNAddTwoStates(9, 10);\r
 500                                                                 break;\r
 501                                                         \r
 502                                                         case 11: \r
 503                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 504                                                                         break;\r
 505                                                                 if (kind > 7)\r
 506                                                                         kind = 7;\r
 507                                                                 JjCheckNAddTwoStates(6, 11);\r
 508                                                                 break;\r
 509                                                         \r
 510                                                         case 12: \r
 511                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 512                                                                         JjAddStates(38, 39);\r
 513                                                                 break;\r
 514                                                         \r
 515                                                         case 13: \r
 516                                                                 if (curChar == 95)\r
 517                                                                         JjCheckNAdd(14);\r
 518                                                                 break;\r
 519                                                         \r
 520                                                         case 14: \r
 521                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 522                                                                         JjCheckNAddTwoStates(14, 15);\r
 523                                                                 break;\r
 524                                                         \r
 525                                                         case 15: \r
 526                                                                 if (curChar == 95)\r
 527                                                                         JjCheckNAddTwoStates(16, 17);\r
 528                                                                 break;\r
 529                                                         \r
 530                                                         case 16: \r
 531                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 532                                                                         JjCheckNAddTwoStates(16, 17);\r
 533                                                                 break;\r
 534                                                         \r
 535                                                         case 18: \r
 536                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 537                                                                         JjAddStates(40, 41);\r
 538                                                                 break;\r
 539                                                         \r
 540                                                         case 19: \r
 541                                                                 if (curChar == 95)\r
 542                                                                         JjCheckNAdd(20);\r
 543                                                                 break;\r
 544                                                         \r
 545                                                         case 20: \r
 546                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 547                                                                         break;\r
 548                                                                 if (kind > 7)\r
 549                                                                         kind = 7;\r
 550                                                                 JjCheckNAddTwoStates(15, 20);\r
 551                                                                 break;\r
 552                                                         \r
 553                                                         case 21: \r
 554                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 555                                                                         break;\r
 556                                                                 if (kind > 1)\r
 557                                                                         kind = 1;\r
 558                                                                 JjCheckNAddStates(0, 17);\r
 559                                                                 break;\r
 560                                                         \r
 561                                                         case 22: \r
 562                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 563                                                                         break;\r
 564                                                                 if (kind > 1)\r
 565                                                                         kind = 1;\r
 566                                                                 JjCheckNAdd(22);\r
 567                                                                 break;\r
 568                                                         \r
 569                                                         case 23: \r
 570                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 571                                                                         JjCheckNAddStates(24, 26);\r
 572                                                                 break;\r
 573                                                         \r
 574                                                         case 24: \r
 575                                                                 if (curChar == 95)\r
 576                                                                         JjCheckNAdd(25);\r
 577                                                                 break;\r
 578                                                         \r
 579                                                         case 25: \r
 580                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 581                                                                         JjCheckNAddStates(27, 29);\r
 582                                                                 break;\r
 583                                                         \r
 584                                                         case 26: \r
 585                                                                 if (curChar == 64)\r
 586                                                                         JjCheckNAdd(27);\r
 587                                                                 break;\r
 588                                                         \r
 589                                                         case 27: \r
 590                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 591                                                                         JjCheckNAddTwoStates(27, 28);\r
 592                                                                 break;\r
 593                                                         \r
 594                                                         case 29: \r
 595                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 596                                                                         break;\r
 597                                                                 if (kind > 5)\r
 598                                                                         kind = 5;\r
 599                                                                 JjCheckNAddTwoStates(28, 29);\r
 600                                                                 break;\r
 601                                                         \r
 602                                                         case 30: \r
 603                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 604                                                                         JjCheckNAddTwoStates(30, 31);\r
 605                                                                 break;\r
 606                                                         \r
 607                                                         case 32: \r
 608                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 609                                                                         break;\r
 610                                                                 if (kind > 6)\r
 611                                                                         kind = 6;\r
 612                                                                 JjCheckNAddTwoStates(31, 32);\r
 613                                                                 break;\r
 614                                                         \r
 615                                                         case 33: \r
 616                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 617                                                                         JjCheckNAddTwoStates(33, 34);\r
 618                                                                 break;\r
 619                                                         \r
 620                                                         case 34: \r
 621                                                                 if (curChar == 95)\r
 622                                                                         JjCheckNAddTwoStates(35, 36);\r
 623                                                                 break;\r
 624                                                         \r
 625                                                         case 35: \r
 626                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 627                                                                         JjCheckNAddTwoStates(35, 36);\r
 628                                                                 break;\r
 629                                                         \r
 630                                                         case 37: \r
 631                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 632                                                                         break;\r
 633                                                                 if (kind > 7)\r
 634                                                                         kind = 7;\r
 635                                                                 jjstateSet[jjnewStateCnt++] = 37;\r
 636                                                                 break;\r
 637                                                         \r
 638                                                         case 38: \r
 639                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 640                                                                         JjCheckNAddTwoStates(38, 39);\r
 641                                                                 break;\r
 642                                                         \r
 643                                                         case 40: \r
 644                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 645                                                                         JjCheckNAddTwoStates(40, 41);\r
 646                                                                 break;\r
 647                                                         \r
 648                                                         case 41: \r
 649                                                                 if (curChar == 95)\r
 650                                                                         JjCheckNAddTwoStates(42, 43);\r
 651                                                                 break;\r
 652                                                         \r
 653                                                         case 42: \r
 654                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 655                                                                         JjCheckNAddTwoStates(42, 43);\r
 656                                                                 break;\r
 657                                                         \r
 658                                                         case 44: \r
 659                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 660                                                                         JjAddStates(42, 43);\r
 661                                                                 break;\r
 662                                                         \r
 663                                                         case 45: \r
 664                                                                 if (curChar == 95)\r
 665                                                                         JjCheckNAdd(46);\r
 666                                                                 break;\r
 667                                                         \r
 668                                                         case 46: \r
 669                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 670                                                                         break;\r
 671                                                                 if (kind > 7)\r
 672                                                                         kind = 7;\r
 673                                                                 JjCheckNAddTwoStates(41, 46);\r
 674                                                                 break;\r
 675                                                         \r
 676                                                         case 47: \r
 677                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 678                                                                         JjCheckNAddTwoStates(47, 48);\r
 679                                                                 break;\r
 680                                                         \r
 681                                                         case 49: \r
 682                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 683                                                                         JjCheckNAddTwoStates(49, 50);\r
 684                                                                 break;\r
 685                                                         \r
 686                                                         case 50: \r
 687                                                                 if (curChar == 95)\r
 688                                                                         JjCheckNAddTwoStates(51, 52);\r
 689                                                                 break;\r
 690                                                         \r
 691                                                         case 51: \r
 692                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 693                                                                         JjCheckNAddTwoStates(51, 52);\r
 694                                                                 break;\r
 695                                                         \r
 696                                                         case 53: \r
 697                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 698                                                                         JjCheckNAddTwoStates(53, 54);\r
 699                                                                 break;\r
 700                                                         \r
 701                                                         case 54: \r
 702                                                                 if (curChar == 95)\r
 703                                                                         JjCheckNAdd(55);\r
 704                                                                 break;\r
 705                                                         \r
 706                                                         case 55: \r
 707                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 708                                                                         JjCheckNAddTwoStates(55, 56);\r
 709                                                                 break;\r
 710                                                         \r
 711                                                         case 56: \r
 712                                                                 if (curChar == 95)\r
 713                                                                         JjCheckNAddTwoStates(57, 58);\r
 714                                                                 break;\r
 715                                                         \r
 716                                                         case 57: \r
 717                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 718                                                                         JjCheckNAddTwoStates(57, 58);\r
 719                                                                 break;\r
 720                                                         \r
 721                                                         case 59: \r
 722                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 723                                                                         break;\r
 724                                                                 if (kind > 7)\r
 725                                                                         kind = 7;\r
 726                                                                 JjCheckNAddTwoStates(54, 59);\r
 727                                                                 break;\r
 728                                                         \r
 729                                                         case 60: \r
 730                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 731                                                                         JjCheckNAddTwoStates(60, 61);\r
 732                                                                 break;\r
 733                                                         \r
 734                                                         case 62: \r
 735                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 736                                                                         JjCheckNAddStates(30, 35);\r
 737                                                                 break;\r
 738                                                         \r
 739                                                         case 63: \r
 740                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 741                                                                         JjCheckNAddTwoStates(63, 64);\r
 742                                                                 break;\r
 743                                                         \r
 744                                                         case 65: \r
 745                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 746                                                                         break;\r
 747                                                                 if (kind > 2)\r
 748                                                                         kind = 2;\r
 749                                                                 JjCheckNAddTwoStates(64, 65);\r
 750                                                                 break;\r
 751                                                         \r
 752                                                         case 66: \r
 753                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 754                                                                         JjCheckNAddTwoStates(66, 67);\r
 755                                                                 break;\r
 756                                                         \r
 757                                                         case 68: \r
 758                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 759                                                                         JjAddStates(44, 45);\r
 760                                                                 break;\r
 761                                                         \r
 762                                                         case 70: \r
 763                                                                 if ((0x7fffffe07fffffeL & l) != (ulong) 0L)\r
 764                                                                         JjCheckNAddTwoStates(70, 71);\r
 765                                                                 break;\r
 766                                                         \r
 767                                                         case 71: \r
 768                                                                 if (curChar == 64)\r
 769                                                                         JjCheckNAdd(72);\r
 770                                                                 break;\r
 771                                                         \r
 772                                                         case 72: \r
 773                                                                 if ((0x7fffffe07fffffeL & l) == (ulong) 0L)\r
 774                                                                         break;\r
 775                                                                 if (kind > 4)\r
 776                                                                         kind = 4;\r
 777                                                                 JjCheckNAdd(72);\r
 778                                                                 break;\r
 779                                                         \r
 780                                                         default:  break;\r
 781                                                         \r
 782                                                 }\r
 783                                         }\r
 784                                         while (ii != startsAt);\r
 785                                 }\r
 786                                 else\r
 787                                 {\r
 788                                         int hiByte = (int) (curChar >> 8);\r
 789                                         int i1 = hiByte >> 6;\r
 790                                         ulong l1 = ((ulong) 1L) << (hiByte & 63);\r
 791                                         int i2 = (curChar & 0xff) >> 6;\r
 792                                         ulong l2 = ((ulong) 1L) << (curChar & 63);\r\r
 793                                         do \r
 794                                         {\r
 795                                                 switch (jjstateSet[--ii])\r
 796                                                 {\r
 797                                                         \r
 798                                                         case 0: \r
 799                                                                 if (jjCanMove_0(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 800                                                                 {\r
 801                                                                         if (kind > 12)\r
 802                                                                                 kind = 12;\r
 803                                                                 }\r
 804                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 805                                                                         JjCheckNAddStates(18, 23);\r
 806                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 807                                                                 {\r
 808                                                                         if (kind > 1)\r
 809                                                                                 kind = 1;\r
 810                                                                         JjCheckNAddStates(0, 17);\r
 811                                                                 }\r
 812                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 813                                                                         JjCheckNAddStates(30, 35);\r
 814                                                                 break;\r
 815                                                         \r
 816                                                         case 1: \r
 817                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 818                                                                         JjCheckNAddStates(18, 23);\r
 819                                                                 break;\r
 820                                                         \r
 821                                                         case 2: \r
 822                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 823                                                                         JjCheckNAddTwoStates(2, 3);\r
 824                                                                 break;\r
 825                                                         \r
 826                                                         case 4: \r
 827                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 828                                                                         break;\r
 829                                                                 if (kind > 7)\r
 830                                                                         kind = 7;\r
 831                                                                 jjstateSet[jjnewStateCnt++] = 4;\r
 832                                                                 break;\r
 833                                                         \r
 834                                                         case 5: \r
 835                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 836                                                                         JjCheckNAddTwoStates(5, 6);\r
 837                                                                 break;\r
 838                                                         \r
 839                                                         case 7: \r
 840                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 841                                                                         JjAddStates(46, 47);\r
 842                                                                 break;\r
 843                                                         \r
 844                                                         case 9: \r
 845                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 846                                                                         JjAddStates(48, 49);\r
 847                                                                 break;\r
 848                                                         \r
 849                                                         case 10: \r
 850                                                                 if (!jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 851                                                                         break;\r
 852                                                                 if (kind > 7)\r
 853                                                                         kind = 7;\r
 854                                                                 JjCheckNAddTwoStates(6, 11);\r
 855                                                                 break;\r
 856                                                         \r
 857                                                         case 11: \r
 858                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 859                                                                         break;\r
 860                                                                 if (kind > 7)\r
 861                                                                         kind = 7;\r
 862                                                                 JjCheckNAddTwoStates(6, 11);\r
 863                                                                 break;\r
 864                                                         \r
 865                                                         case 12: \r
 866                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 867                                                                         JjCheckNAddTwoStates(12, 13);\r
 868                                                                 break;\r
 869                                                         \r
 870                                                         case 14: \r
 871                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 872                                                                         JjCheckNAddTwoStates(14, 15);\r
 873                                                                 break;\r
 874                                                         \r
 875                                                         case 16: \r
 876                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 877                                                                         JjAddStates(50, 51);\r
 878                                                                 break;\r
 879                                                         \r
 880                                                         case 17: \r
 881                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 882                                                                         JjCheckNAddTwoStates(18, 19);\r
 883                                                                 break;\r
 884                                                         \r
 885                                                         case 18: \r
 886                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 887                                                                         JjCheckNAddTwoStates(18, 19);\r
 888                                                                 break;\r
 889                                                         \r
 890                                                         case 20: \r
 891                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 892                                                                         break;\r
 893                                                                 if (kind > 7)\r
 894                                                                         kind = 7;\r
 895                                                                 JjCheckNAddTwoStates(15, 20);\r
 896                                                                 break;\r
 897                                                         \r
 898                                                         case 21: \r
 899                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 900                                                                         break;\r
 901                                                                 if (kind > 1)\r
 902                                                                         kind = 1;\r
 903                                                                 JjCheckNAddStates(0, 17);\r
 904                                                                 break;\r
 905                                                         \r
 906                                                         case 22: \r
 907                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 908                                                                         break;\r
 909                                                                 if (kind > 1)\r
 910                                                                         kind = 1;\r
 911                                                                 JjCheckNAdd(22);\r
 912                                                                 break;\r
 913                                                         \r
 914                                                         case 23: \r
 915                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 916                                                                         JjCheckNAddStates(24, 26);\r
 917                                                                 break;\r
 918                                                         \r
 919                                                         case 25: \r
 920                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 921                                                                         JjCheckNAddStates(27, 29);\r
 922                                                                 break;\r
 923                                                         \r
 924                                                         case 27: \r
 925                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 926                                                                         JjCheckNAddTwoStates(27, 28);\r
 927                                                                 break;\r
 928                                                         \r
 929                                                         case 29: \r
 930                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 931                                                                         break;\r
 932                                                                 if (kind > 5)\r
 933                                                                         kind = 5;\r
 934                                                                 JjCheckNAddTwoStates(28, 29);\r
 935                                                                 break;\r
 936                                                         \r
 937                                                         case 30: \r
 938                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 939                                                                         JjCheckNAddTwoStates(30, 31);\r
 940                                                                 break;\r
 941                                                         \r
 942                                                         case 32: \r
 943                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 944                                                                         break;\r
 945                                                                 if (kind > 6)\r
 946                                                                         kind = 6;\r
 947                                                                 JjCheckNAddTwoStates(31, 32);\r
 948                                                                 break;\r
 949                                                         \r
 950                                                         case 33: \r
 951                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 952                                                                         JjCheckNAddTwoStates(33, 34);\r
 953                                                                 break;\r
 954                                                         \r
 955                                                         case 35: \r
 956                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 957                                                                         JjAddStates(52, 53);\r
 958                                                                 break;\r
 959                                                         \r
 960                                                         case 36: \r
 961                                                                 if (!jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 962                                                                         break;\r
 963                                                                 if (kind > 7)\r
 964                                                                         kind = 7;\r
 965                                                                 JjCheckNAdd(37);\r
 966                                                                 break;\r
 967                                                         \r
 968                                                         case 37: \r
 969                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 970                                                                         break;\r
 971                                                                 if (kind > 7)\r
 972                                                                         kind = 7;\r
 973                                                                 JjCheckNAdd(37);\r
 974                                                                 break;\r
 975                                                         \r
 976                                                         case 38: \r
 977                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 978                                                                         JjCheckNAddTwoStates(38, 39);\r
 979                                                                 break;\r
 980                                                         \r
 981                                                         case 39: \r
 982                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 983                                                                         JjCheckNAddTwoStates(2, 3);\r
 984                                                                 break;\r
 985                                                         \r
 986                                                         case 40: \r
 987                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 988                                                                         JjCheckNAddTwoStates(40, 41);\r
 989                                                                 break;\r
 990                                                         \r
 991                                                         case 42: \r
 992                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 993                                                                         JjAddStates(54, 55);\r
 994                                                                 break;\r
 995                                                         \r
 996                                                         case 43: \r
 997                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
 998                                                                         JjCheckNAddTwoStates(44, 45);\r
 999                                                                 break;\r
1000                                                         \r
1001                                                         case 44: \r
1002                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1003                                                                         JjCheckNAddTwoStates(44, 45);\r
1004                                                                 break;\r
1005                                                         \r
1006                                                         case 46: \r
1007                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1008                                                                         break;\r
1009                                                                 if (kind > 7)\r
1010                                                                         kind = 7;\r
1011                                                                 JjCheckNAddTwoStates(41, 46);\r
1012                                                                 break;\r
1013                                                         \r
1014                                                         case 47: \r
1015                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1016                                                                         JjCheckNAddTwoStates(47, 48);\r
1017                                                                 break;\r
1018                                                         \r
1019                                                         case 48: \r
1020                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1021                                                                         JjCheckNAddTwoStates(5, 6);\r
1022                                                                 break;\r
1023                                                         \r
1024                                                         case 49: \r
1025                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1026                                                                         JjCheckNAddTwoStates(49, 50);\r
1027                                                                 break;\r
1028                                                         \r
1029                                                         case 51: \r
1030                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1031                                                                         JjAddStates(56, 57);\r
1032                                                                 break;\r
1033                                                         \r
1034                                                         case 52: \r
1035                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1036                                                                         JjCheckNAddTwoStates(53, 54);\r
1037                                                                 break;\r
1038                                                         \r
1039                                                         case 53: \r
1040                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1041                                                                         JjCheckNAddTwoStates(53, 54);\r
1042                                                                 break;\r
1043                                                         \r
1044                                                         case 55: \r
1045                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1046                                                                         JjAddStates(58, 59);\r
1047                                                                 break;\r
1048                                                         \r
1049                                                         case 57: \r
1050                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1051                                                                         JjAddStates(60, 61);\r
1052                                                                 break;\r
1053                                                         \r
1054                                                         case 58: \r
1055                                                                 if (!jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1056                                                                         break;\r
1057                                                                 if (kind > 7)\r
1058                                                                         kind = 7;\r
1059                                                                 JjCheckNAddTwoStates(54, 59);\r
1060                                                                 break;\r
1061                                                         \r
1062                                                         case 59: \r
1063                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1064                                                                         break;\r
1065                                                                 if (kind > 7)\r
1066                                                                         kind = 7;\r
1067                                                                 JjCheckNAddTwoStates(54, 59);\r
1068                                                                 break;\r
1069                                                         \r
1070                                                         case 60: \r
1071                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1072                                                                         JjCheckNAddTwoStates(60, 61);\r
1073                                                                 break;\r
1074                                                         \r
1075                                                         case 61: \r
1076                                                                 if (jjCanMove_1(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1077                                                                         JjCheckNAddTwoStates(12, 13);\r
1078                                                                 break;\r
1079                                                         \r
1080                                                         case 62: \r
1081                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1082                                                                         JjCheckNAddStates(30, 35);\r
1083                                                                 break;\r
1084                                                         \r
1085                                                         case 63: \r
1086                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1087                                                                         JjCheckNAddTwoStates(63, 64);\r
1088                                                                 break;\r
1089                                                         \r
1090                                                         case 65: \r
1091                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1092                                                                         break;\r
1093                                                                 if (kind > 2)\r
1094                                                                         kind = 2;\r
1095                                                                 JjCheckNAddTwoStates(64, 65);\r
1096                                                                 break;\r
1097                                                         \r
1098                                                         case 66: \r
1099                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1100                                                                         JjCheckNAddTwoStates(66, 67);\r
1101                                                                 break;\r
1102                                                         \r
1103                                                         case 68: \r
1104                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1105                                                                         JjAddStates(44, 45);\r
1106                                                                 break;\r
1107                                                         \r
1108                                                         case 70: \r
1109                                                                 if (jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1110                                                                         JjCheckNAddTwoStates(70, 71);\r
1111                                                                 break;\r
1112                                                         \r
1113                                                         case 72: \r
1114                                                                 if (!jjCanMove_2(hiByte, i1, i2, (ulong) l1, (ulong) l2))\r
1115                                                                         break;\r
1116                                                                 if (kind > 4)\r
1117                                                                         kind = 4;\r
1118                                                                 jjstateSet[jjnewStateCnt++] = 72;\r
1119                                                                 break;\r
1120                                                         \r
1121                                                         default:  break;\r
1122                                                         \r
1123                                                 }\r
1124                                         }\r
1125                                         while (ii != startsAt);\r
1126                                 }\r
1127                                 if (kind != 0x7fffffff)\r
1128                                 {\r
1129                                         jjmatchedKind = kind;\r
1130                                         jjmatchedPos = curPos;\r
1131                                         kind = 0x7fffffff;\r
1132                                 }\r
1133                                 ++curPos;\r
1134                                 if ((ii = jjnewStateCnt) == (startsAt = 73 - (jjnewStateCnt = startsAt)))\r
1135                                         return curPos;\r
1136                                 try\r
1137                                 {\r
1138                                         curChar = input_stream.ReadChar();\r
1139                                 }\r
1140                                 catch (System.IO.IOException)\r
1141                                 {\r
1142                                         return curPos;\r
1143                                 }\r
1144                         }\r
1145                 }\r
1146                 internal static readonly int[] jjnextStates = new int[]{22, 23, 24, 26, 30, 31, 33, 34, 38, 39, 40, 41, 47, 48, 49, 50, 60, 61, 2, 3, 5, 6, 12, 13, 23, 24, 26, 24, 25, 26, 63, 64, 66, 67, 70, 71, 2, 3, 12, 13, 18, 19, 44, 45, 68, 69, 7, 8, 9, 10, 16, 17, 35, 36, 42, 43, 51, 52, 55, 56, 57, 58};\r
1147                 private static bool jjCanMove_0(int hiByte, int i1, int i2, ulong l1, ulong l2)\r
1148                 {\r
1149                         switch (hiByte)\r
1150                         {\r
1151                                 \r
1152                                 case 48: \r
1153                                         return ((jjbitVec2[i2] & l2) != (ulong) 0L);\r
1154                                 \r
1155                                 case 49: \r
1156                                         return ((jjbitVec3[i2] & l2) != (ulong) 0L);\r
1157                                 \r
1158                                 case 51: \r
1159                                         return ((jjbitVec4[i2] & l2) != (ulong) 0L);\r
1160                                 \r
1161                                 case 61: \r
1162                                         return ((jjbitVec5[i2] & l2) != (ulong) 0L);\r
1163                                 \r
1164                                 default: \r
1165                                         if ((jjbitVec0[i1] & l1) != (ulong) 0L)\r
1166                                                 return true;\r
1167                                         return false;\r
1168                                 \r
1169                         }\r
1170                 }\r
1171                 private static bool jjCanMove_1(int hiByte, int i1, int i2, ulong l1, ulong l2)\r
1172                 {\r
1173                         switch (hiByte)\r
1174                         {\r
1175                                 \r
1176                                 case 6: \r
1177                                         return ((jjbitVec8[i2] & l2) != (ulong) 0L);\r
1178                                 \r
1179                                 case 11: \r
1180                                         return ((jjbitVec9[i2] & l2) != (ulong) 0L);\r
1181                                 \r
1182                                 case 13: \r
1183                                         return ((jjbitVec10[i2] & l2) != (ulong) 0L);\r
1184                                 \r
1185                                 case 14: \r
1186                                         return ((jjbitVec11[i2] & l2) != (ulong) 0L);\r
1187                                 \r
1188                                 case 16: \r
1189                                         return ((jjbitVec12[i2] & l2) != (ulong) 0L);\r
1190                                 \r
1191                                 default: \r
1192                                         if ((jjbitVec6[i1] & l1) != (ulong) 0L)\r
1193                                                 if ((jjbitVec7[i2] & l2) == (ulong) 0L)\r
1194                                                         return false;\r
1195                                                 else\r
1196                                                         return true;\r
1197                                         return false;\r
1198                                 \r
1199                         }\r
1200                 }\r
1201                 private static bool jjCanMove_2(int hiByte, int i1, int i2, ulong l1, ulong l2)\r
1202                 {\r
1203                         switch (hiByte)\r
1204                         {\r
1205                                 \r
1206                                 case 0: \r
1207                                         return ((jjbitVec14[i2] & l2) != (ulong) 0L);\r
1208                                 \r
1209                                 default: \r
1210                                         if ((jjbitVec13[i1] & l1) != (ulong) 0L)\r
1211                                                 return true;\r
1212                                         return false;\r
1213                                 \r
1214                         }\r
1215                 }\r
1216                 public static readonly System.String[] jjstrLiteralImages = new System.String[]{"", null, null, null, null, null, null, null, null, null, null, null, null, null, null};\r
1217                 public static readonly System.String[] lexStateNames = new System.String[]{"DEFAULT"};\r
1218                 internal static readonly long[] jjtoToken = new long[]{0x10ffL};\r
1219                 internal static readonly long[] jjtoSkip = new long[]{0x4000L};\r
1220                 protected internal CharStream input_stream;\r
1221                 private uint[] jjrounds = new uint[73];\r
1222                 private int[] jjstateSet = new int[146];\r
1223                 protected internal char curChar;\r
1224                 public StandardTokenizerTokenManager(CharStream stream)\r
1225                 {\r
1226                         InitBlock();\r
1227                         input_stream = stream;\r
1228                 }\r
1229                 public StandardTokenizerTokenManager(CharStream stream, int lexState):this(stream)\r
1230                 {\r
1231                         SwitchTo(lexState);\r
1232                 }\r
1233                 public virtual void  ReInit(CharStream stream)\r
1234                 {\r
1235                         jjmatchedPos = jjnewStateCnt = 0;\r
1236                         curLexState = defaultLexState;\r
1237                         input_stream = stream;\r
1238                         ReInitRounds();\r
1239                 }\r
1240                 private void  ReInitRounds()\r
1241                 {\r
1242                         int i;\r
1243                         jjround = 0x80000001;\r
1244                         for (i = 73; i-- > 0; )\r
1245                                 jjrounds[i] = 0x80000000;\r
1246                 }\r
1247                 public virtual void  ReInit(CharStream stream, int lexState)\r
1248                 {\r
1249                         ReInit(stream);\r
1250                         SwitchTo(lexState);\r
1251                 }\r
1252                 public virtual void  SwitchTo(int lexState)\r
1253                 {\r
1254                         if (lexState >= 1 || lexState < 0)\r
1255                                 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);\r
1256                         else\r
1257                                 curLexState = lexState;\r
1258                 }\r
1259                 \r
1260                 protected internal virtual Token JjFillToken()\r
1261                 {\r
1262                         Token t = Token.NewToken(jjmatchedKind);\r
1263                         t.kind = jjmatchedKind;\r
1264                         System.String im = jjstrLiteralImages[jjmatchedKind];\r
1265                         t.image = (im == null) ? input_stream.GetImage() : im;\r
1266                         t.beginLine = input_stream.GetBeginLine();\r
1267                         t.beginColumn = input_stream.GetBeginColumn();\r
1268                         t.endLine = input_stream.GetEndLine();\r
1269                         t.endColumn = input_stream.GetEndColumn();\r
1270                         return t;\r
1271                 }\r
1272                 \r
1273                 internal int curLexState = 0;\r
1274                 internal int defaultLexState = 0;\r
1275                 internal int jjnewStateCnt;\r
1276                 internal uint jjround;\r
1277                 internal int jjmatchedPos;\r
1278                 internal int jjmatchedKind;\r
1279                 \r
1280                 public virtual Token GetNextToken()\r
1281                 {\r
1282                         Token matchedToken;\r
1283                         int curPos = 0;\r
1284                         \r
1285                         for (; ; )\r
1286                         {\r
1287                                 try\r
1288                                 {\r
1289                                         curChar = input_stream.BeginToken();\r
1290                                 }\r
1291                                 catch (System.IO.IOException)\r
1292                                 {\r
1293                                         jjmatchedKind = 0;\r
1294                                         matchedToken = JjFillToken();\r
1295                                         return matchedToken;\r
1296                                 }\r
1297                                 \r
1298                                 jjmatchedKind = 0x7fffffff;\r
1299                                 jjmatchedPos = 0;\r
1300                                 curPos = JjMoveStringLiteralDfa0_0();\r
1301                                 if (jjmatchedPos == 0 && jjmatchedKind > 14)\r
1302                                 {\r
1303                                         jjmatchedKind = 14;\r
1304                                 }\r
1305                                 if (jjmatchedKind != 0x7fffffff)\r
1306                                 {\r
1307                                         if (jjmatchedPos + 1 < curPos)\r
1308                                                 input_stream.Backup(curPos - jjmatchedPos - 1);\r
1309                                         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)\r
1310                                         {\r
1311                                                 matchedToken = JjFillToken();\r
1312                                                 return matchedToken;\r
1313                                         }\r
1314                                         else\r
1315                                         {\r
1316                                                 goto EOFLoop;\r
1317                                         }\r
1318                                 }\r
1319                                 int error_line = input_stream.GetEndLine();\r
1320                                 int error_column = input_stream.GetEndColumn();\r
1321                                 System.String error_after = null;\r
1322                                 bool EOFSeen = false;\r
1323                                 try\r
1324                                 {\r
1325                                         input_stream.ReadChar(); input_stream.Backup(1);\r
1326                                 }\r
1327                                 catch (System.IO.IOException)\r
1328                                 {\r
1329                                         EOFSeen = true;\r
1330                                         error_after = curPos <= 1?"":input_stream.GetImage();\r
1331                                         if (curChar == '\n' || curChar == '\r')\r
1332                                         {\r
1333                                                 error_line++;\r
1334                                                 error_column = 0;\r
1335                                         }\r
1336                                         else\r
1337                                                 error_column++;\r
1338                                 }\r
1339                                 if (!EOFSeen)\r
1340                                 {\r
1341                                         input_stream.Backup(1);\r
1342                                         error_after = curPos <= 1?"":input_stream.GetImage();\r
1343                                 }\r
1344                                 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);\r
1345 \r
1346 EOFLoop: ;\r
1347                         }\r
1348                 }\r
1349         }\r
1350 }