Update jflex to 1.8.2
[scilab.git] / scilab / modules / helptools / src / java / org / scilab / modules / helptools / XML / XMLLexer.java
1 // DO NOT EDIT
2 // Generated by JFlex 1.8.2 http://jflex.de/
3 // source: jflex/xml.jflex
4
5 //CHECKSTYLE:OFF
6
7 package org.scilab.modules.helptools.XML;
8
9 import java.io.Reader;
10 import java.io.StringReader;
11 import java.io.IOException;
12
13 @javax.annotation.Generated("JFlex")
14
15 // See https://github.com/jflex-de/jflex/issues/222
16 @SuppressWarnings("FallThrough")
17 public final class XMLLexer {
18
19   /** This character denotes the end of file. */
20   public static final int YYEOF = -1;
21
22   /** Initial size of the lookahead buffer. */
23   private static final int ZZ_BUFFERSIZE = 16384;
24
25   // Lexical states.
26   public static final int YYINITIAL = 0;
27   public static final int COMMENT = 2;
28   public static final int CDATA = 4;
29   public static final int TAG = 6;
30   public static final int PI = 8;
31   public static final int CLEAN = 10;
32   public static final int CLEANFIRST = 12;
33
34   /**
35    * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
36    * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
37    *                  at the beginning of a line
38    * l is of the form l = 2*k, k a non negative integer
39    */
40   private static final int ZZ_LEXSTATE[] = {
41      0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6, 6
42   };
43
44   /**
45    * Top-level table for translating characters to character classes
46    */
47   private static final int [] ZZ_CMAP_TOP = zzUnpackcmap_top();
48
49   private static final String ZZ_CMAP_TOP_PACKED_0 =
50     "\1\0\2\u0100\1\u0200\34\u0300\1\u0400\1\u0500\12\u0600\3\u0700"+
51     "\1\u0800\1\u0900\247\u0a00\10\u0b00\31\u0600\4\u0c00\1\u0d00\1\u0e00"+
52     "\1\u0f00\u1000\u0600";
53
54   private static int [] zzUnpackcmap_top() {
55     int [] result = new int[4352];
56     int offset = 0;
57     offset = zzUnpackcmap_top(ZZ_CMAP_TOP_PACKED_0, offset, result);
58     return result;
59   }
60
61   private static int zzUnpackcmap_top(String packed, int offset, int [] result) {
62     int i = 0;       /* index in packed string  */
63     int j = offset;  /* index in unpacked array */
64     int l = packed.length();
65     while (i < l) {
66       int count = packed.charAt(i++);
67       int value = packed.charAt(i++);
68       do result[j++] = value; while (--count > 0);
69     }
70     return j;
71   }
72
73
74   /**
75    * Second-level tables for translating characters to character classes
76    */
77   private static final int [] ZZ_CMAP_BLOCKS = zzUnpackcmap_blocks();
78
79   private static final String ZZ_CMAP_BLOCKS_PACKED_0 =
80     "\11\0\1\1\1\2\2\3\1\2\22\0\1\1\1\4"+
81     "\1\5\1\6\2\0\1\7\1\10\5\0\1\11\1\12"+
82     "\1\13\12\14\1\15\1\16\1\17\1\20\1\21\1\22"+
83     "\1\0\1\23\1\24\1\25\1\26\17\24\1\27\6\24"+
84     "\1\30\1\12\1\31\1\12\1\15\1\12\32\24\12\12"+
85     "\1\32\72\12\27\15\1\12\37\15\1\12\u0108\15\160\12"+
86     "\16\15\1\12\u0181\15\14\12\2\15\32\12\2\32\27\12"+
87     "\57\0\u0120\15\u0170\0\u01f0\15\21\0\u01ff\15\u0100\3\u01d0\15"+
88     "\40\0\u020e\15\2\0";
89
90   private static int [] zzUnpackcmap_blocks() {
91     int [] result = new int[4096];
92     int offset = 0;
93     offset = zzUnpackcmap_blocks(ZZ_CMAP_BLOCKS_PACKED_0, offset, result);
94     return result;
95   }
96
97   private static int zzUnpackcmap_blocks(String packed, int offset, int [] result) {
98     int i = 0;       /* index in packed string  */
99     int j = offset;  /* index in unpacked array */
100     int l = packed.length();
101     while (i < l) {
102       int count = packed.charAt(i++);
103       int value = packed.charAt(i++);
104       do result[j++] = value; while (--count > 0);
105     }
106     return j;
107   }
108
109   /**
110    * Translates DFA states to action switch labels.
111    */
112   private static final int [] ZZ_ACTION = zzUnpackAction();
113
114   private static final String ZZ_ACTION_PACKED_0 =
115     "\1\1\1\2\1\3\4\0\1\1\1\4\1\1\1\0"+
116     "\1\2\1\5\1\0\1\3\1\6\1\0\1\7\1\10"+
117     "\1\11\4\7\1\12\1\13\1\7\1\14\1\15\1\16"+
118     "\1\17\1\20\1\7\1\21\2\0\1\22\6\0\1\23"+
119     "\1\0\1\24\1\0\1\25\1\26\3\0\1\27\1\0"+
120     "\1\30\1\0\1\31\1\32\2\0\1\33\4\0\1\34";
121
122   private static int [] zzUnpackAction() {
123     int [] result = new int[66];
124     int offset = 0;
125     offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
126     return result;
127   }
128
129   private static int zzUnpackAction(String packed, int offset, int [] result) {
130     int i = 0;       /* index in packed string  */
131     int j = offset;  /* index in unpacked array */
132     int l = packed.length();
133     while (i < l) {
134       int count = packed.charAt(i++);
135       int value = packed.charAt(i++);
136       do result[j++] = value; while (--count > 0);
137     }
138     return j;
139   }
140
141
142   /**
143    * Translates a state to a row index in the transition table
144    */
145   private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
146
147   private static final String ZZ_ROWMAP_PACKED_0 =
148     "\0\0\0\33\0\66\0\121\0\154\0\207\0\242\0\275"+
149     "\0\330\0\363\0\u010e\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
150     "\0\u01b0\0\u01cb\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252\0\u026d"+
151     "\0\u01cb\0\u0288\0\u02a3\0\u01cb\0\u02be\0\u02d9\0\u01cb\0\u02f4"+
152     "\0\u030f\0\275\0\u032a\0\u0345\0\u0360\0\u037b\0\u0396\0\u03b1"+
153     "\0\u03cc\0\u03e7\0\u021c\0\u01cb\0\u0237\0\u01cb\0\u026d\0\u01cb"+
154     "\0\u01cb\0\u0402\0\u041d\0\u0438\0\u0453\0\u046e\0\u01cb\0\u0489"+
155     "\0\u01cb\0\u01cb\0\u04a4\0\u04bf\0\u01cb\0\u04da\0\u04f5\0\u0510"+
156     "\0\u052b\0\u01cb";
157
158   private static int [] zzUnpackRowMap() {
159     int [] result = new int[66];
160     int offset = 0;
161     offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
162     return result;
163   }
164
165   private static int zzUnpackRowMap(String packed, int offset, int [] result) {
166     int i = 0;  /* index in packed string  */
167     int j = offset;  /* index in unpacked array */
168     int l = packed.length();
169     while (i < l) {
170       int high = packed.charAt(i++) << 16;
171       result[j++] = high | packed.charAt(i++);
172     }
173     return j;
174   }
175
176   /**
177    * The transition table of the DFA
178    */
179   private static final int [] ZZ_TRANS = zzUnpackTrans();
180
181   private static final String ZZ_TRANS_PACKED_0 =
182     "\2\10\1\11\4\10\1\12\7\10\1\13\13\10\2\14"+
183     "\1\15\6\14\1\16\21\14\2\17\1\20\26\17\1\21"+
184     "\1\17\1\22\1\23\1\24\1\0\1\22\1\25\2\22"+
185     "\1\26\2\22\1\27\1\22\1\30\3\22\1\31\1\22"+
186     "\5\30\2\22\1\0\1\22\1\23\1\32\1\0\1\22"+
187     "\1\25\2\22\1\26\4\22\1\30\4\22\1\33\5\30"+
188     "\2\22\1\0\1\34\1\35\1\36\1\0\26\34\1\0"+
189     "\1\37\1\40\1\41\1\0\26\37\1\0\2\10\1\0"+
190     "\14\10\1\0\13\10\2\0\1\11\30\0\2\10\1\0"+
191     "\3\10\1\12\5\10\1\12\1\10\1\42\1\0\3\10"+
192     "\5\12\3\10\4\0\1\43\6\0\1\44\1\0\1\45"+
193     "\4\0\1\46\5\45\3\0\2\14\1\0\6\14\1\47"+
194     "\21\14\2\0\1\15\30\0\2\14\1\0\6\14\1\50"+
195     "\21\14\2\17\1\0\26\17\1\51\1\17\2\0\1\20"+
196     "\30\0\2\17\1\0\26\17\1\52\1\17\34\0\1\23"+
197     "\33\0\1\24\30\0\2\53\1\0\2\53\1\54\25\53"+
198     "\2\55\1\0\5\55\1\54\22\55\21\0\1\56\22\0"+
199     "\2\57\1\0\2\57\2\0\1\60\2\0\10\57\2\0"+
200     "\1\32\51\0\1\61\12\0\1\35\33\0\1\36\31\0"+
201     "\1\40\1\41\32\0\1\41\41\0\1\62\16\0\1\63"+
202     "\17\0\1\64\5\0\5\64\14\0\2\45\1\0\2\45"+
203     "\5\0\10\45\15\0\1\65\5\0\5\65\3\0\2\14"+
204     "\1\0\6\14\1\66\23\14\1\0\16\14\1\67\11\14"+
205     "\2\17\1\0\26\17\1\70\3\17\1\0\16\17\1\71"+
206     "\11\17\11\0\1\72\46\0\1\73\6\0\1\74\7\0"+
207     "\2\64\1\0\2\64\3\0\1\75\1\0\10\64\11\0"+
208     "\2\65\1\0\2\65\5\0\10\65\2\14\1\0\16\14"+
209     "\1\0\11\14\2\17\1\0\16\17\1\0\11\17\26\0"+
210     "\1\76\5\0\1\74\17\0\1\75\34\0\1\77\36\0"+
211     "\1\100\26\0\1\101\37\0\1\102\2\0";
212
213   private static int [] zzUnpackTrans() {
214     int [] result = new int[1350];
215     int offset = 0;
216     offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result);
217     return result;
218   }
219
220   private static int zzUnpackTrans(String packed, int offset, int [] result) {
221     int i = 0;       /* index in packed string  */
222     int j = offset;  /* index in unpacked array */
223     int l = packed.length();
224     while (i < l) {
225       int count = packed.charAt(i++);
226       int value = packed.charAt(i++);
227       value--;
228       do result[j++] = value; while (--count > 0);
229     }
230     return j;
231   }
232
233
234   /** Error code for "Unknown internal scanner error". */
235   private static final int ZZ_UNKNOWN_ERROR = 0;
236   /** Error code for "could not match input". */
237   private static final int ZZ_NO_MATCH = 1;
238   /** Error code for "pushback value was too large". */
239   private static final int ZZ_PUSHBACK_2BIG = 2;
240
241   /**
242    * Error messages for {@link #ZZ_UNKNOWN_ERROR}, {@link #ZZ_NO_MATCH}, and
243    * {@link #ZZ_PUSHBACK_2BIG} respectively.
244    */
245   private static final String ZZ_ERROR_MSG[] = {
246     "Unknown internal scanner error",
247     "Error: could not match input",
248     "Error: pushback value was too large"
249   };
250
251   /**
252    * ZZ_ATTRIBUTE[aState] contains the attributes of state {@code aState}
253    */
254   private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
255
256   private static final String ZZ_ATTRIBUTE_PACKED_0 =
257     "\3\1\4\0\3\1\1\0\2\1\1\0\2\1\1\0"+
258     "\1\11\6\1\1\11\2\1\1\11\2\1\1\11\3\1"+
259     "\2\0\1\1\6\0\1\11\1\0\1\11\1\0\2\11"+
260     "\3\0\1\1\1\0\1\11\1\0\2\11\2\0\1\11"+
261     "\4\0\1\11";
262
263   private static int [] zzUnpackAttribute() {
264     int [] result = new int[66];
265     int offset = 0;
266     offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
267     return result;
268   }
269
270   private static int zzUnpackAttribute(String packed, int offset, int [] result) {
271     int i = 0;       /* index in packed string  */
272     int j = offset;  /* index in unpacked array */
273     int l = packed.length();
274     while (i < l) {
275       int count = packed.charAt(i++);
276       int value = packed.charAt(i++);
277       do result[j++] = value; while (--count > 0);
278     }
279     return j;
280   }
281
282   /** Input device. */
283   private java.io.Reader zzReader;
284
285   /** Current state of the DFA. */
286   private int zzState;
287
288   /** Current lexical state. */
289   private int zzLexicalState = YYINITIAL;
290
291   /**
292    * This buffer contains the current text to be matched and is the source of the {@link #yytext()}
293    * string.
294    */
295   private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
296
297   /** Text position at the last accepting state. */
298   private int zzMarkedPos;
299
300   /** Current text position in the buffer. */
301   private int zzCurrentPos;
302
303   /** Marks the beginning of the {@link #yytext()} string in the buffer. */
304   private int zzStartRead;
305
306   /** Marks the last character in the buffer, that has been read from input. */
307   private int zzEndRead;
308
309   /**
310    * Whether the scanner is at the end of file.
311    * @see #yyatEOF
312    */
313   private boolean zzAtEOF;
314
315   /**
316    * The number of occupied positions in {@link #zzBuffer} beyond {@link #zzEndRead}.
317    *
318    * <p>When a lead/high surrogate has been read from the input stream into the final
319    * {@link #zzBuffer} position, this will have a value of 1; otherwise, it will have a value of 0.
320    */
321   private int zzFinalHighSurrogate = 0;
322
323   /** Number of newlines encountered up to the start of the matched text. */
324   @SuppressWarnings("unused")
325   private int yyline;
326
327   /** Number of characters from the last newline up to the start of the matched text. */
328   @SuppressWarnings("unused")
329   private int yycolumn;
330
331   /** Number of characters up to the start of the matched text. */
332   private long yychar;
333
334   /** Whether the scanner is currently at the beginning of a line. */
335   @SuppressWarnings("unused")
336   private boolean zzAtBOL = true;
337
338   /** Whether the user-EOF-code has already been executed. */
339   @SuppressWarnings("unused")
340   private boolean zzEOFDone;
341
342   /* user code: */
343
344     private int whitesOnFirstLine;
345     private int saveLexState;
346     private AbstractXMLCodeHandler handler;
347
348     public XMLLexer() { }
349
350     private String trimEnd(String str) {
351         int end = str.length() - 1;
352         int i = end;
353         for (; i >= 0; i--) {
354            char c = str.charAt(i);
355            if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
356               break;
357            }
358         }
359         if (i != end) {
360            return str.substring(0, i + 1);
361         }
362
363         return str;
364     }
365
366     public String convert(AbstractXMLCodeHandler h, String code) {
367         Reader reader = new StringReader(trimEnd(code));
368         String str = convert(h, reader, true);
369         try {
370           reader.close();
371         } catch (IOException e) { }
372
373         return str;
374     }
375
376     public String convert(AbstractXMLCodeHandler h, Reader code, boolean ret) {
377         if (code == null) {
378            return null;
379         } else {
380            handler = h;
381            whitesOnFirstLine = 0;
382            yyreset(code);
383            yybegin(CLEANFIRST);
384            try {
385                yylex();
386            } catch (IOException e) {
387                return null;
388            }
389            if (ret) {
390                return h.toString();
391            }
392            return "";
393         }
394     }
395
396
397   /**
398    * Creates a new scanner
399    *
400    * @param   in  the java.io.Reader to read input from.
401    */
402   public XMLLexer(java.io.Reader in) {
403     this.zzReader = in;
404   }
405
406   /**
407    * Translates raw input code points to DFA table row
408    */
409   private static int zzCMap(int input) {
410     int offset = input & 255;
411     return offset == input ? ZZ_CMAP_BLOCKS[offset] : ZZ_CMAP_BLOCKS[ZZ_CMAP_TOP[input >> 8] | offset];
412   }
413
414   /**
415    * Refills the input buffer.
416    *
417    * @return {@code false} iff there was new input.
418    * @exception java.io.IOException  if any I/O-Error occurs
419    */
420   private boolean zzRefill() throws java.io.IOException {
421
422     /* first: make room (if you can) */
423     if (zzStartRead > 0) {
424       zzEndRead += zzFinalHighSurrogate;
425       zzFinalHighSurrogate = 0;
426       System.arraycopy(zzBuffer, zzStartRead,
427                        zzBuffer, 0,
428                        zzEndRead - zzStartRead);
429
430       /* translate stored positions */
431       zzEndRead -= zzStartRead;
432       zzCurrentPos -= zzStartRead;
433       zzMarkedPos -= zzStartRead;
434       zzStartRead = 0;
435     }
436
437     /* is the buffer big enough? */
438     if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate) {
439       /* if not: blow it up */
440       char newBuffer[] = new char[zzBuffer.length * 2];
441       System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
442       zzBuffer = newBuffer;
443       zzEndRead += zzFinalHighSurrogate;
444       zzFinalHighSurrogate = 0;
445     }
446
447     /* fill the buffer with new input */
448     int requested = zzBuffer.length - zzEndRead;
449     int numRead = zzReader.read(zzBuffer, zzEndRead, requested);
450
451     /* not supposed to occur according to specification of java.io.Reader */
452     if (numRead == 0) {
453       throw new java.io.IOException(
454           "Reader returned 0 characters. See JFlex examples/zero-reader for a workaround.");
455     }
456     if (numRead > 0) {
457       zzEndRead += numRead;
458       if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) {
459         if (numRead == requested) { // We requested too few chars to encode a full Unicode character
460           --zzEndRead;
461           zzFinalHighSurrogate = 1;
462         } else {                    // There is room in the buffer for at least one more char
463           int c = zzReader.read();  // Expecting to read a paired low surrogate char
464           if (c == -1) {
465             return true;
466           } else {
467             zzBuffer[zzEndRead++] = (char)c;
468           }
469         }
470       }
471       /* potentially more input available */
472       return false;
473     }
474
475     /* numRead < 0 ==> end of stream */
476     return true;
477   }
478
479
480   /**
481    * Closes the input reader.
482    *
483    * @throws java.io.IOException if the reader could not be closed.
484    */
485   public final void yyclose() throws java.io.IOException {
486     zzAtEOF = true; // indicate end of file
487     zzEndRead = zzStartRead; // invalidate buffer
488
489     if (zzReader != null) {
490       zzReader.close();
491     }
492   }
493
494
495   /**
496    * Resets the scanner to read from a new input stream.
497    *
498    * <p>Does not close the old reader.
499    *
500    * <p>All internal variables are reset, the old input stream <b>cannot</b> be reused (internal
501    * buffer is discarded and lost). Lexical state is set to {@code ZZ_INITIAL}.
502    *
503    * <p>Internal scan buffer is resized down to its initial length, if it has grown.
504    *
505    * @param reader The new input stream.
506    */
507   public final void yyreset(java.io.Reader reader) {
508     zzReader = reader;
509     zzEOFDone = false;
510     yyResetPosition();
511     zzLexicalState = YYINITIAL;
512     if (zzBuffer.length > ZZ_BUFFERSIZE) {
513       zzBuffer = new char[ZZ_BUFFERSIZE];
514     }
515   }
516
517   /**
518    * Resets the input position.
519    */
520   private final void yyResetPosition() {
521       zzAtBOL  = true;
522       zzAtEOF  = false;
523       zzCurrentPos = 0;
524       zzMarkedPos = 0;
525       zzStartRead = 0;
526       zzEndRead = 0;
527       zzFinalHighSurrogate = 0;
528       yyline = 0;
529       yycolumn = 0;
530       yychar = 0L;
531   }
532
533
534   /**
535    * Returns whether the scanner has reached the end of the reader it reads from.
536    *
537    * @return whether the scanner has reached EOF.
538    */
539   public final boolean yyatEOF() {
540     return zzAtEOF;
541   }
542
543
544   /**
545    * Returns the current lexical state.
546    *
547    * @return the current lexical state.
548    */
549   public final int yystate() {
550     return zzLexicalState;
551   }
552
553
554   /**
555    * Enters a new lexical state.
556    *
557    * @param newState the new lexical state
558    */
559   public final void yybegin(int newState) {
560     zzLexicalState = newState;
561   }
562
563
564   /**
565    * Returns the text matched by the current regular expression.
566    *
567    * @return the matched text.
568    */
569   public final String yytext() {
570     return new String(zzBuffer, zzStartRead, zzMarkedPos-zzStartRead);
571   }
572
573
574   /**
575    * Returns the character at the given position from the matched text.
576    *
577    * <p>It is equivalent to {@code yytext().charAt(pos)}, but faster.
578    *
579    * @param position the position of the character to fetch. A value from 0 to {@code yylength()-1}.
580    *
581    * @return the character at {@code position}.
582    */
583   public final char yycharat(int position) {
584     return zzBuffer[zzStartRead + position];
585   }
586
587
588   /**
589    * How many characters were matched.
590    *
591    * @return the length of the matched text region.
592    */
593   public final int yylength() {
594     return zzMarkedPos-zzStartRead;
595   }
596
597
598   /**
599    * Reports an error that occurred while scanning.
600    *
601    * <p>In a well-formed scanner (no or only correct usage of {@code yypushback(int)} and a
602    * match-all fallback rule) this method will only be called with things that
603    * "Can't Possibly Happen".
604    *
605    * <p>If this method is called, something is seriously wrong (e.g. a JFlex bug producing a faulty
606    * scanner etc.).
607    *
608    * <p>Usual syntax/scanner level error handling should be done in error fallback rules.
609    *
610    * @param errorCode the code of the error message to display.
611    */
612   private static void zzScanError(int errorCode) {
613     String message;
614     try {
615       message = ZZ_ERROR_MSG[errorCode];
616     } catch (ArrayIndexOutOfBoundsException e) {
617       message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
618     }
619
620     throw new Error(message);
621   }
622
623
624   /**
625    * Pushes the specified amount of characters back into the input stream.
626    *
627    * <p>They will be read again by then next call of the scanning method.
628    *
629    * @param number the number of characters to be read again. This number must not be greater than
630    *     {@link #yylength()}.
631    */
632   public void yypushback(int number)  {
633     if ( number > yylength() )
634       zzScanError(ZZ_PUSHBACK_2BIG);
635
636     zzMarkedPos -= number;
637   }
638
639
640
641
642   /**
643    * Resumes scanning until the next regular expression is matched, the end of input is encountered
644    * or an I/O-Error occurs.
645    *
646    * @return the next token.
647    * @exception java.io.IOException if any I/O-Error occurs.
648    */
649   public void yylex() throws java.io.IOException {
650     int zzInput;
651     int zzAction;
652
653     // cached fields:
654     int zzCurrentPosL;
655     int zzMarkedPosL;
656     int zzEndReadL = zzEndRead;
657     char[] zzBufferL = zzBuffer;
658
659     int [] zzTransL = ZZ_TRANS;
660     int [] zzRowMapL = ZZ_ROWMAP;
661     int [] zzAttrL = ZZ_ATTRIBUTE;
662
663     while (true) {
664       zzMarkedPosL = zzMarkedPos;
665
666       yychar+= zzMarkedPosL-zzStartRead;
667
668       zzAction = -1;
669
670       zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
671
672       zzState = ZZ_LEXSTATE[zzLexicalState];
673
674       // set up zzAction for empty match case:
675       int zzAttributes = zzAttrL[zzState];
676       if ( (zzAttributes & 1) == 1 ) {
677         zzAction = zzState;
678       }
679
680
681       zzForAction: {
682         while (true) {
683
684           if (zzCurrentPosL < zzEndReadL) {
685             zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
686             zzCurrentPosL += Character.charCount(zzInput);
687           }
688           else if (zzAtEOF) {
689             zzInput = YYEOF;
690             break zzForAction;
691           }
692           else {
693             // store back cached positions
694             zzCurrentPos  = zzCurrentPosL;
695             zzMarkedPos   = zzMarkedPosL;
696             boolean eof = zzRefill();
697             // get translated positions and possibly new buffer
698             zzCurrentPosL  = zzCurrentPos;
699             zzMarkedPosL   = zzMarkedPos;
700             zzBufferL      = zzBuffer;
701             zzEndReadL     = zzEndRead;
702             if (eof) {
703               zzInput = YYEOF;
704               break zzForAction;
705             }
706             else {
707               zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
708               zzCurrentPosL += Character.charCount(zzInput);
709             }
710           }
711           int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMap(zzInput) ];
712           if (zzNext == -1) break zzForAction;
713           zzState = zzNext;
714
715           zzAttributes = zzAttrL[zzState];
716           if ( (zzAttributes & 1) == 1 ) {
717             zzAction = zzState;
718             zzMarkedPosL = zzCurrentPosL;
719             if ( (zzAttributes & 8) == 8 ) break zzForAction;
720           }
721
722         }
723       }
724
725       // store back cached position
726       zzMarkedPos = zzMarkedPosL;
727
728       if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
729         zzAtEOF = true;
730               {
731                 return;
732               }
733       }
734       else {
735         switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
736           case 1:
737             { handler.handleDefault(yytext());
738             }
739             // fall through
740           case 29: break;
741           case 2:
742             { handler.handleComment(yytext());
743             }
744             // fall through
745           case 30: break;
746           case 3:
747             { handler.handleCdata(yytext());
748             }
749             // fall through
750           case 31: break;
751           case 4:
752             { handler.handleNothing("\n");
753                                      saveLexState = YYINITIAL;
754                                      yybegin(CLEAN);
755             }
756             // fall through
757           case 32: break;
758           case 5:
759             { handler.handleNothing("\n");
760                                      saveLexState = COMMENT;
761                                      yybegin(CLEAN);
762             }
763             // fall through
764           case 33: break;
765           case 6:
766             { handler.handleNothing("\n");
767                                      saveLexState = CDATA;
768                                      yybegin(CLEAN);
769             }
770             // fall through
771           case 34: break;
772           case 7:
773             { 
774             }
775             // fall through
776           case 35: break;
777           case 8:
778             { handler.handleNothing(" ");
779             }
780             // fall through
781           case 36: break;
782           case 9:
783             { handler.handleNothing("\n");
784                                      saveLexState = TAG;
785                                      yybegin(CLEAN);
786             }
787             // fall through
788           case 37: break;
789           case 10:
790             { yybegin(YYINITIAL);
791                                      handler.handleGreat("&#0062;");
792             }
793             // fall through
794           case 38: break;
795           case 11:
796             { handler.handleNothing("\n");
797                                      saveLexState = PI;
798                                      yybegin(CLEAN);
799             }
800             // fall through
801           case 39: break;
802           case 12:
803             { yypushback(1);
804                                      yybegin(saveLexState);
805             }
806             // fall through
807           case 40: break;
808           case 13:
809             { int len = yylength() - whitesOnFirstLine;
810                                      if (len > 0) {
811                                         yypushback(len);
812                                      }
813                                      yybegin(saveLexState);
814             }
815             // fall through
816           case 41: break;
817           case 14:
818             { handler.handleNothing("\n");
819             }
820             // fall through
821           case 42: break;
822           case 15:
823             { yypushback(1);
824                                      yybegin(YYINITIAL);
825             }
826             // fall through
827           case 43: break;
828           case 16:
829             { whitesOnFirstLine = yylength();
830                                      yybegin(YYINITIAL);
831             }
832             // fall through
833           case 44: break;
834           case 17:
835             { handler.handleEntity("&amp;" + yytext().substring(1));
836             }
837             // fall through
838           case 45: break;
839           case 18:
840             { yybegin(TAG);
841                                      handler.handleLow("&#0060;");
842                                      handler.handleOpenTagName(yytext().substring(1));
843             }
844             // fall through
845           case 46: break;
846           case 19:
847             { handler.handleAttributeValue(yytext());
848             }
849             // fall through
850           case 47: break;
851           case 20:
852             { yybegin(YYINITIAL);
853                                      handler.handleAutoClose("/&#0062;");
854             }
855             // fall through
856           case 48: break;
857           case 21:
858             { String str = yytext();
859                                      handler.handleAttributeName(str.substring(0, str.length() - 1));
860                                      handler.handleEqual("=");
861             }
862             // fall through
863           case 49: break;
864           case 22:
865             { yybegin(YYINITIAL);
866                                      handler.handleCloseInstr("?&#0062;");
867             }
868             // fall through
869           case 50: break;
870           case 23:
871             { yybegin(PI);
872                                      handler.handleOpenInstr("&#0060;?");
873                                      handler.handleInstrName(yytext().substring(2));
874             }
875             // fall through
876           case 51: break;
877           case 24:
878             { yybegin(YYINITIAL);
879                                      handler.handleCommentEnd("--&#0062;");
880             }
881             // fall through
882           case 52: break;
883           case 25:
884             { yybegin(YYINITIAL);
885                                      handler.handleCdataEnd("]]&#0062;");
886             }
887             // fall through
888           case 53: break;
889           case 26:
890             { yybegin(COMMENT);
891                                      handler.handleOpenComment("&#0060;!--");
892             }
893             // fall through
894           case 54: break;
895           case 27:
896             { handler.handleLowClose("&#0060;/");
897                                      String str = yytext();
898                                      handler.handleOpenTagName(str.substring(2, str.length() - 1).trim());
899                                      handler.handleGreat("&#0062;");
900             }
901             // fall through
902           case 55: break;
903           case 28:
904             { yybegin(CDATA);
905                                      handler.handleOpenCdata("&#0060;![CDATA[");
906             }
907             // fall through
908           case 56: break;
909           default:
910             zzScanError(ZZ_NO_MATCH);
911         }
912       }
913     }
914   }
915
916
917 }