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