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