Method: next_token()

1: /* The following code was generated by JFlex 1.7.0 */
2:
3: /*****************************************************************************
4: * @file grammar/varass_scanner.l
5: * Scanner for files containing variable assignments.
6: *
7: * Copyright (c) 2012-2016 The fli4l team
8: *
9: * This file is part of fli4l.
10: *
11: * fli4l is free software: you can redistribute it and/or modify
12: * it under the terms of the GNU General Public License as published by
13: * the Free Software Foundation, either version 3 of the License, or
14: * (at your option) any later version.
15: *
16: * fli4l is distributed in the hope that it will be useful,
17: * but WITHOUT ANY WARRANTY; without even the implied warranty of
18: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19: * GNU General Public License for more details.
20: *
21: * You should have received a copy of the GNU General Public License
22: * along with fli4l. If not, see <http://www.gnu.org/licenses/>.
23: *
24: * Last Update: $Id$
25: *****************************************************************************
26: */
27:
28: package scanner;
29: import parser.Parser;
30: import parser.ParserVal;
31:
32:
33: /**
34: * This class is a scanner generated by
35: * <a href="http://www.jflex.de/">JFlex</a> 1.7.0
36: * from the specification file <tt>C:/jflex-1.7.0/bin/aktuellerStand.flex</tt>
37: */
38: public class VarDefScanner {
39:
40: /** This character denotes the end of file */
41: public static final int YYEOF = -1;
42:
43: /** initial size of the lookahead buffer */
44: private static final int ZZ_BUFFERSIZE = 16384;
45:
46: /** lexical states */
47: public static final int YYINITIAL = 0;
48:
49: /**
50: * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
51: * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
52: * at the beginning of a line
53: * l is of the form l = 2*k, k a non negative integer
54: */
55: private static final int ZZ_LEXSTATE[] = {
56: 0, 1
57: };
58:
59: /**
60: * Translates characters to character classes
61: */
62: private static final String ZZ_CMAP_PACKED =
63: "\11\0\1\12\1\15\1\21\1\21\1\14\22\0\1\12\1\0\1\17"+
64: "\1\22\1\0\1\11\1\0\1\16\6\0\1\24\1\0\1\5\11\6"+
65: "\3\0\1\23\3\0\32\4\1\25\1\20\1\26\1\0\1\7\1\0"+
66: "\25\10\1\13\4\10\1\27\1\0\1\30\7\0\1\21\65\0\1\2"+
67: "\3\0\1\3\57\0\1\1\u1f38\0\1\21\1\21\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\udfe6\0";
68:
69: /**
70: * Translates characters to character classes
71: */
72: private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
73:
74: /**
75: * Translates DFA states to action switch labels.
76: */
77: private static final int [] ZZ_ACTION = zzUnpackAction();
78:
79: private static final String ZZ_ACTION_PACKED_0 =
80: "\2\0\2\1\1\2\1\3\1\1\1\4\1\1\1\4"+
81: "\2\1\1\5\1\6\1\7\1\10\1\11\1\12\1\13"+
82: "\1\1\1\4\1\1\1\4\1\0\1\1\1\0\1\1"+
83: "\1\14\1\0\1\1\1\15\6\0\1\2\4\0\1\4"+
84: "\1\0";
85:
86: private static int [] zzUnpackAction() {
87: int [] result = new int[44];
88: int offset = 0;
89: offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
90: return result;
91: }
92:
93: private static int zzUnpackAction(String packed, int offset, int [] result) {
94: int i = 0; /* index in packed string */
95: int j = offset; /* index in unpacked array */
96: int l = packed.length();
97: while (i < l) {
98: int count = packed.charAt(i++);
99: int value = packed.charAt(i++);
100: do result[j++] = value; while (--count > 0);
101: }
102: return j;
103: }
104:
105:
106: /**
107: * Translates a state to a row index in the transition table
108: */
109: private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
110:
111: private static final String ZZ_ROWMAP_PACKED_0 =
112: "\0\0\0\31\0\62\0\113\0\144\0\175\0\226\0\257"+
113: "\0\310\0\62\0\341\0\372\0\u0113\0\62\0\62\0\62"+
114: "\0\62\0\62\0\62\0\u012c\0\u0145\0\u015e\0\u0177\0\u0190"+
115: "\0\u01a9\0\u01c2\0\u01db\0\62\0\u01f4\0\u020d\0\62\0\u0226"+
116: "\0\u023f\0\u0258\0\u0271\0\u028a\0\u02a3\0\u02bc\0\u02d5\0\u02ee"+
117: "\0\u0307\0\u0320\0\u0339\0\u0339";
118:
119: private static int [] zzUnpackRowMap() {
120: int [] result = new int[44];
121: int offset = 0;
122: offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
123: return result;
124: }
125:
126: private static int zzUnpackRowMap(String packed, int offset, int [] result) {
127: int i = 0; /* index in packed string */
128: int j = offset; /* index in unpacked array */
129: int l = packed.length();
130: while (i < l) {
131: int high = packed.charAt(i++) << 16;
132: result[j++] = high | packed.charAt(i++);
133: }
134: return j;
135: }
136:
137: /**
138: * The transition table of the DFA
139: */
140: private static final int [] ZZ_TRANS = zzUnpackTrans();
141:
142: private static final String ZZ_TRANS_PACKED_0 =
143: "\1\3\1\4\2\3\1\5\1\3\1\6\1\3\1\7"+
144: "\1\3\1\10\1\11\2\12\1\13\1\14\1\3\1\0"+
145: "\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\3"+
146: "\1\24\2\3\1\5\1\3\1\6\1\3\1\7\1\3"+
147: "\1\25\1\26\2\12\1\13\1\14\1\3\1\0\1\27"+
148: "\1\16\1\17\1\20\1\21\1\22\1\23\33\0\1\30"+
149: "\32\0\3\5\1\31\2\7\1\0\1\7\22\0\2\6"+
150: "\26\0\6\7\1\0\1\7\27\0\2\10\21\0\6\7"+
151: "\1\10\1\11\15\0\14\13\1\32\1\33\1\34\12\13"+
152: "\14\14\1\35\1\36\1\14\1\37\1\40\10\14\14\15"+
153: "\1\41\1\42\13\15\2\0\1\43\40\0\2\25\6\0"+
154: "\1\27\12\0\6\7\1\25\1\26\6\0\1\27\6\0"+
155: "\14\27\1\44\1\45\13\27\3\0\1\12\31\0\1\5"+
156: "\1\7\1\46\3\7\1\0\1\7\32\0\1\33\25\0"+
157: "\2\47\1\32\1\33\1\34\27\0\1\36\25\0\2\50"+
158: "\1\35\1\36\1\0\1\37\11\0\14\14\1\51\4\14"+
159: "\1\0\7\14\15\0\1\42\25\0\2\52\20\0\1\53"+
160: "\42\0\1\45\25\0\2\54\21\0\1\7\2\46\1\31"+
161: "\2\7\1\0\1\7\15\0\14\13\3\0\12\13\14\14"+
162: "\2\0\1\14\1\0\1\40\10\14\15\0\1\14\25\0"+
163: "\2\52\6\0\1\15\20\0\2\54\6\0\1\27\6\0";
164:
165: private static int [] zzUnpackTrans() {
166: int [] result = new int[850];
167: int offset = 0;
168: offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result);
169: return result;
170: }
171:
172: private static int zzUnpackTrans(String packed, int offset, int [] result) {
173: int i = 0; /* index in packed string */
174: int j = offset; /* index in unpacked array */
175: int l = packed.length();
176: while (i < l) {
177: int count = packed.charAt(i++);
178: int value = packed.charAt(i++);
179: value--;
180: do result[j++] = value; while (--count > 0);
181: }
182: return j;
183: }
184:
185:
186: /* error codes */
187: private static final int ZZ_UNKNOWN_ERROR = 0;
188: private static final int ZZ_NO_MATCH = 1;
189: private static final int ZZ_PUSHBACK_2BIG = 2;
190:
191: /* error messages for the codes above */
192: private static final String ZZ_ERROR_MSG[] = {
193: "Unknown internal scanner error",
194: "Error: could not match input",
195: "Error: pushback value was too large"
196: };
197:
198: /**
199: * ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
200: */
201: private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
202:
203: private static final String ZZ_ATTRIBUTE_PACKED_0 =
204: "\2\0\1\11\6\1\1\11\3\1\6\11\4\1\1\0"+
205: "\1\1\1\0\1\1\1\11\1\0\1\1\1\11\6\0"+
206: "\1\1\4\0\1\1\1\0";
207:
208: private static int [] zzUnpackAttribute() {
209: int [] result = new int[44];
210: int offset = 0;
211: offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
212: return result;
213: }
214:
215: private static int zzUnpackAttribute(String packed, int offset, int [] result) {
216: int i = 0; /* index in packed string */
217: int j = offset; /* index in unpacked array */
218: int l = packed.length();
219: while (i < l) {
220: int count = packed.charAt(i++);
221: int value = packed.charAt(i++);
222: do result[j++] = value; while (--count > 0);
223: }
224: return j;
225: }
226:
227: /** the input device */
228: private java.io.Reader zzReader;
229:
230: /** the current state of the DFA */
231: private int zzState;
232:
233: /** the current lexical state */
234: private int zzLexicalState = YYINITIAL;
235:
236: /** this buffer contains the current text to be matched and is
237: the source of the yytext() string */
238: private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
239:
240: /** the textposition at the last accepting state */
241: private int zzMarkedPos;
242:
243: /** the current text position in the buffer */
244: private int zzCurrentPos;
245:
246: /** startRead marks the beginning of the yytext() string in the buffer */
247: private int zzStartRead;
248:
249: /** endRead marks the last character in the buffer, that has been read
250: from input */
251: private int zzEndRead;
252:
253: /** number of newlines encountered up to the start of the matched text */
254: private int yyline;
255:
256: /** the number of characters up to the start of the matched text */
257: private int yychar;
258:
259: /**
260: * the number of characters from the last newline up to the start of the
261: * matched text
262: */
263: private int yycolumn;
264:
265: /**
266: * zzAtBOL == true iff the scanner is currently at the beginning of a line
267: */
268: private boolean zzAtBOL = true;
269:
270: /** zzAtEOF == true iff the scanner is at the EOF */
271: private boolean zzAtEOF;
272:
273: /** denotes if the user-EOF-code has already been executed */
274: private boolean zzEOFDone;
275:
276: /**
277: * The number of occupied positions in zzBuffer beyond zzEndRead.
278: * When a lead/high surrogate has been read from the input stream
279: * into the final zzBuffer position, this will have a value of 1;
280: * otherwise, it will have a value of 0.
281: */
282: private int zzFinalHighSurrogate = 0;
283:
284: /* user code: */
285: /* store a reference to the parser object */
286: private Parser parser = new Parser();
287: /* constructor taking an additional parser object */
288: public VarDefScanner(java.io.Reader reader, Parser parser) {
289: this.zzReader = reader;
290: this.parser = parser;
291: }
292:
293:
294: /**
295: * Creates a new scanner
296: *
297: * @param in the java.io.Reader to read input from.
298: */
299: public VarDefScanner(java.io.Reader in) {
300: this.zzReader = in;
301: }
302:
303:
304: /**
305: * Unpacks the compressed character translation table.
306: *
307: * @param packed the packed character translation table
308: * @return the unpacked character translation table
309: */
310: private static char [] zzUnpackCMap(String packed) {
311: char [] map = new char[0x110000];
312: int i = 0; /* index in packed string */
313: int j = 0; /* index in unpacked array */
314: while (i < 128) {
315: int count = packed.charAt(i++);
316: char value = packed.charAt(i++);
317: do map[j++] = value; while (--count > 0);
318: }
319: return map;
320: }
321:
322:
323: /**
324: * Refills the input buffer.
325: *
326: * @return <code>false</code>, iff there was new input.
327: *
328: * @exception java.io.IOException if any I/O-Error occurs
329: */
330: private boolean zzRefill() throws java.io.IOException {
331:
332: /* first: make room (if you can) */
333: if (zzStartRead > 0) {
334: zzEndRead += zzFinalHighSurrogate;
335: zzFinalHighSurrogate = 0;
336: System.arraycopy(zzBuffer, zzStartRead,
337: zzBuffer, 0,
338: zzEndRead-zzStartRead);
339:
340: /* translate stored positions */
341: zzEndRead-= zzStartRead;
342: zzCurrentPos-= zzStartRead;
343: zzMarkedPos-= zzStartRead;
344: zzStartRead = 0;
345: }
346:
347: /* is the buffer big enough? */
348: if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate) {
349: /* if not: blow it up */
350: char newBuffer[] = new char[zzBuffer.length*2];
351: System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
352: zzBuffer = newBuffer;
353: zzEndRead += zzFinalHighSurrogate;
354: zzFinalHighSurrogate = 0;
355: }
356:
357: /* fill the buffer with new input */
358: int requested = zzBuffer.length - zzEndRead;
359: int numRead = zzReader.read(zzBuffer, zzEndRead, requested);
360:
361: /* not supposed to occur according to specification of java.io.Reader */
362: if (numRead == 0) {
363: throw new java.io.IOException("Reader returned 0 characters. See JFlex examples for workaround.");
364: }
365: if (numRead > 0) {
366: zzEndRead += numRead;
367: /* If numRead == requested, we might have requested to few chars to
368: encode a full Unicode character. We assume that a Reader would
369: otherwise never return half characters. */
370: if (numRead == requested) {
371: if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) {
372: --zzEndRead;
373: zzFinalHighSurrogate = 1;
374: }
375: }
376: /* potentially more input available */
377: return false;
378: }
379:
380: /* numRead < 0 ==> end of stream */
381: return true;
382: }
383:
384:
385: /**
386: * Closes the input stream.
387: */
388: public final void yyclose() throws java.io.IOException {
389: zzAtEOF = true; /* indicate end of file */
390: zzEndRead = zzStartRead; /* invalidate buffer */
391:
392: if (zzReader != null)
393: zzReader.close();
394: }
395:
396:
397: /**
398: * Resets the scanner to read from a new input stream.
399: * Does not close the old reader.
400: *
401: * All internal variables are reset, the old input stream
402: * <b>cannot</b> be reused (internal buffer is discarded and lost).
403: * Lexical state is set to <tt>ZZ_INITIAL</tt>.
404: *
405: * Internal scan buffer is resized down to its initial length, if it has grown.
406: *
407: * @param reader the new input stream
408: */
409: public final void yyreset(java.io.Reader reader) {
410: zzReader = reader;
411: zzAtBOL = true;
412: zzAtEOF = false;
413: zzEOFDone = false;
414: zzEndRead = zzStartRead = 0;
415: zzCurrentPos = zzMarkedPos = 0;
416: zzFinalHighSurrogate = 0;
417: yyline = yychar = yycolumn = 0;
418: zzLexicalState = YYINITIAL;
419: if (zzBuffer.length > ZZ_BUFFERSIZE)
420: zzBuffer = new char[ZZ_BUFFERSIZE];
421: }
422:
423:
424: /**
425: * Returns the current lexical state.
426: */
427: public final int yystate() {
428: return zzLexicalState;
429: }
430:
431:
432: /**
433: * Enters a new lexical state
434: *
435: * @param newState the new lexical state
436: */
437: public final void yybegin(int newState) {
438: zzLexicalState = newState;
439: }
440:
441:
442: /**
443: * Returns the text matched by the current regular expression.
444: */
445: public final String yytext() {
446: return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
447: }
448:
449:
450: /**
451: * Returns the character at position <tt>pos</tt> from the
452: * matched text.
453: *
454: * It is equivalent to yytext().charAt(pos), but faster
455: *
456: * @param pos the position of the character to fetch.
457: * A value from 0 to yylength()-1.
458: *
459: * @return the character at position pos
460: */
461: public final char yycharat(int pos) {
462: return zzBuffer[zzStartRead+pos];
463: }
464:
465:
466: /**
467: * Returns the length of the matched text region.
468: */
469: public final int yylength() {
470: return zzMarkedPos-zzStartRead;
471: }
472:
473:
474: /**
475: * Reports an error that occured while scanning.
476: *
477: * In a wellformed scanner (no or only correct usage of
478: * yypushback(int) and a match-all fallback rule) this method
479: * will only be called with things that "Can't Possibly Happen".
480: * If this method is called, something is seriously wrong
481: * (e.g. a JFlex bug producing a faulty scanner etc.).
482: *
483: * Usual syntax/scanner level error handling should be done
484: * in error fallback rules.
485: *
486: * @param errorCode the code of the errormessage to display
487: */
488: private void zzScanError(int errorCode) {
489: String message;
490: try {
491: message = ZZ_ERROR_MSG[errorCode];
492: }
493: catch (ArrayIndexOutOfBoundsException e) {
494: message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
495: }
496:
497: throw new Error(message);
498: }
499:
500:
501: /**
502: * Pushes the specified amount of characters back into the input stream.
503: *
504: * They will be read again by then next call of the scanning method
505: *
506: * @param number the number of characters to be read again.
507: * This number must not be greater than yylength()!
508: */
509: public void yypushback(int number) {
510: if ( number > yylength() )
511: zzScanError(ZZ_PUSHBACK_2BIG);
512:
513: zzMarkedPos -= number;
514: }
515:
516:
517: /**
518: * Resumes scanning until the next regular expression is matched,
519: * the end of input is encountered or an I/O-Error occurs.
520: *
521: * @return the next token
522: * @exception java.io.IOException if any I/O-Error occurs
523: */
524: public int next_token() throws java.io.IOException {
525: int zzInput;
526: int zzAction;
527:
528: // cached fields:
529: int zzCurrentPosL;
530: int zzMarkedPosL;
531: int zzEndReadL = zzEndRead;
532: char [] zzBufferL = zzBuffer;
533: char [] zzCMapL = ZZ_CMAP;
534:
535: int [] zzTransL = ZZ_TRANS;
536: int [] zzRowMapL = ZZ_ROWMAP;
537: int [] zzAttrL = ZZ_ATTRIBUTE;
538:
539: while (true) {
540: zzMarkedPosL = zzMarkedPos;
541:
542:• if (zzMarkedPosL > zzStartRead) {
543:• switch (zzBufferL[zzMarkedPosL-1]) {
544: case '\n':
545: case '\u000B': // fall through
546: case '\u000C': // fall through
547: case '\u0085': // fall through
548: case '\u2028': // fall through
549: case '\u2029': // fall through
550: zzAtBOL = true;
551: break;
552: case '\r':
553:• if (zzMarkedPosL < zzEndReadL)
554:• zzAtBOL = zzBufferL[zzMarkedPosL] != '\n';
555:• else if (zzAtEOF)
556: zzAtBOL = false;
557: else {
558: boolean eof = zzRefill();
559: zzMarkedPosL = zzMarkedPos;
560: zzEndReadL = zzEndRead;
561: zzBufferL = zzBuffer;
562:• if (eof)
563: zzAtBOL = false;
564: else
565:• zzAtBOL = zzBufferL[zzMarkedPosL] != '\n';
566: }
567: break;
568: default:
569: zzAtBOL = false;
570: }
571: }
572: zzAction = -1;
573:
574: zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
575:
576:• if (zzAtBOL)
577: zzState = ZZ_LEXSTATE[zzLexicalState+1];
578: else
579: zzState = ZZ_LEXSTATE[zzLexicalState];
580:
581: // set up zzAction for empty match case:
582: int zzAttributes = zzAttrL[zzState];
583:• if ( (zzAttributes & 1) == 1 ) {
584: zzAction = zzState;
585: }
586:
587:
588: zzForAction: {
589: while (true) {
590:
591:• if (zzCurrentPosL < zzEndReadL) {
592: zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
593: zzCurrentPosL += Character.charCount(zzInput);
594: }
595:• else if (zzAtEOF) {
596: zzInput = YYEOF;
597: break zzForAction;
598: }
599: else {
600: // store back cached positions
601: zzCurrentPos = zzCurrentPosL;
602: zzMarkedPos = zzMarkedPosL;
603: boolean eof = zzRefill();
604: // get translated positions and possibly new buffer
605: zzCurrentPosL = zzCurrentPos;
606: zzMarkedPosL = zzMarkedPos;
607: zzBufferL = zzBuffer;
608: zzEndReadL = zzEndRead;
609:• if (eof) {
610: zzInput = YYEOF;
611: break zzForAction;
612: }
613: else {
614: zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
615: zzCurrentPosL += Character.charCount(zzInput);
616: }
617: }
618: int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
619:• if (zzNext == -1) break zzForAction;
620: zzState = zzNext;
621:
622: zzAttributes = zzAttrL[zzState];
623:• if ( (zzAttributes & 1) == 1 ) {
624: zzAction = zzState;
625: zzMarkedPosL = zzCurrentPosL;
626:• if ( (zzAttributes & 8) == 8 ) break zzForAction;
627: }
628:
629: }
630: }
631:
632: // store back cached position
633: zzMarkedPos = zzMarkedPosL;
634:
635:• if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
636: zzAtEOF = true;
637: { return 0;
638: }
639: }
640: else {
641:• switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
642: case 1:
643: { return Parser.UNKNOWN;
644: }
645: // fall through
646: case 14: break;
647: case 2:
648: { parser.yylval = new ParserVal(yytext());
649: return Parser.ID;
650: }
651: // fall through
652: case 15: break;
653: case 3:
654: { parser.yylval = new ParserVal(Integer.valueOf(yytext()));
655: return Parser.ABSOLUTE_INDEX;
656: }
657: // fall through
658: case 16: break;
659: case 4:
660: {
661: }
662: // fall through
663: case 17: break;
664: case 5:
665: { parser.yylval = new ParserVal(yytext());
666: return Parser.COMMENT;
667: }
668: // fall through
669: case 18: break;
670: case 6:
671: { return Parser.EQ;
672: }
673: // fall through
674: case 19: break;
675: case 7:
676: { return Parser.DOT;
677: }
678: // fall through
679: case 20: break;
680: case 8:
681: { return Parser.LBRACKET;
682: }
683: // fall through
684: case 21: break;
685: case 9:
686: { return Parser.RBRACKET;
687: }
688: // fall through
689: case 22: break;
690: case 10:
691: { return Parser.LBRACE;
692: }
693: // fall through
694: case 23: break;
695: case 11:
696: { return Parser.RBRACE;
697: }
698: // fall through
699: case 24: break;
700: case 12:
701: { parser.yylval = new ParserVal("\'" + yytext() + "\'");
702: return Parser.QSTRING;
703: }
704: // fall through
705: case 25: break;
706: case 13:
707: { parser.yylval = new ParserVal('"' + yytext() + '"');
708: return Parser.QSTRING;
709: }
710: // fall through
711: case 26: break;
712: default:
713: zzScanError(ZZ_NO_MATCH);
714: }
715: }
716: }
717: }
718:
719:
720: }