/** This character denotes the end of file. */ public static final int YYEOF = -1; /** Initial size of the lookahead buffer. */ --- private static final int ZZ_BUFFERSIZE = ...; /** Lexical states. */ --- lexical states, charmap /** Error code for "Unknown internal scanner error". */ private static final int ZZ_UNKNOWN_ERROR = 0; /** Error code for "could not match input". */ private static final int ZZ_NO_MATCH = 1; /** Error code for "pushback value was too large". */ private static final int ZZ_PUSHBACK_2BIG = 2; /** * Error messages for {@link #ZZ_UNKNOWN_ERROR}, {@link #ZZ_NO_MATCH}, and * {@link #ZZ_PUSHBACK_2BIG} respectively. */ private static final String ZZ_ERROR_MSG[] = { "Unknown internal scanner error", "Error: could not match input", "Error: pushback value was too large" }; --- isFinal list /** Input device. */ private java.io.Reader zzReader; /** Current state of the DFA. */ private int zzState; /** Current lexical state. */ private int zzLexicalState = YYINITIAL; /** * This buffer contains the current text to be matched and is the source of the {@link #yytext()} * string. */ private char zzBuffer[] = new char[ZZ_BUFFERSIZE]; /** Text position at the last accepting state. */ private int zzMarkedPos; /** Current text position in the buffer. */ private int zzCurrentPos; /** Marks the beginning of the {@link #yytext()} string in the buffer. */ private int zzStartRead; /** Marks the last character in the buffer, that has been read from input. */ private int zzEndRead; /** * Whether the scanner is at the end of file. * @see #yyatEOF */ private boolean zzAtEOF; /** * The number of occupied positions in {@link #zzBuffer} beyond {@link #zzEndRead}. * *

When a lead/high surrogate has been read from the input stream into the final * {@link #zzBuffer} position, this will have a value of 1; otherwise, it will have a value of 0. */ private int zzFinalHighSurrogate = 0; --- user class code --- constructor declaration /** * Refills the input buffer. * * @return {@code false} iff there was new input. * @exception java.io.IOException if any I/O-Error occurs */ private boolean zzRefill() throws java.io.IOException { /* first: make room (if you can) */ if (zzStartRead > 0) { zzEndRead += zzFinalHighSurrogate; zzFinalHighSurrogate = 0; System.arraycopy(zzBuffer, zzStartRead, zzBuffer, 0, zzEndRead - zzStartRead); /* translate stored positions */ zzEndRead -= zzStartRead; zzCurrentPos -= zzStartRead; zzMarkedPos -= zzStartRead; zzStartRead = 0; } /* is the buffer big enough? */ if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate) { /* if not: blow it up */ char newBuffer[] = new char[zzBuffer.length * 2]; System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length); zzBuffer = newBuffer; zzEndRead += zzFinalHighSurrogate; zzFinalHighSurrogate = 0; } /* fill the buffer with new input */ int requested = zzBuffer.length - zzEndRead; int numRead = zzReader.read(zzBuffer, zzEndRead, requested); /* not supposed to occur according to specification of java.io.Reader */ if (numRead == 0) { throw new java.io.IOException( "Reader returned 0 characters. See JFlex examples/zero-reader for a workaround."); } if (numRead > 0) { zzEndRead += numRead; if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) { if (numRead == requested) { // We requested too few chars to encode a full Unicode character --zzEndRead; zzFinalHighSurrogate = 1; } else { // There is room in the buffer for at least one more char int c = zzReader.read(); // Expecting to read a paired low surrogate char if (c == -1) { return true; } else { zzBuffer[zzEndRead++] = (char)c; } } } /* potentially more input available */ return false; } /* numRead < 0 ==> end of stream */ return true; } /** * Closes the input reader. * * @throws java.io.IOException if the reader could not be closed. */ public final void yyclose() throws java.io.IOException { zzAtEOF = true; // indicate end of file zzEndRead = zzStartRead; // invalidate buffer if (zzReader != null) { zzReader.close(); } } /** * Resets the scanner to read from a new input stream. * *

Does not close the old reader. * *

All internal variables are reset, the old input stream cannot be reused (internal * buffer is discarded and lost). Lexical state is set to {@code ZZ_INITIAL}. * *

Internal scan buffer is resized down to its initial length, if it has grown. * * @param reader The new input stream. */ public final void yyreset(java.io.Reader reader) { zzReader = reader; zzEOFDone = false; yyResetPosition(); zzLexicalState = YYINITIAL; if (zzBuffer.length > ZZ_BUFFERSIZE) { zzBuffer = new char[ZZ_BUFFERSIZE]; } } /** * Resets the input position. */ private final void yyResetPosition() { zzAtBOL = true; zzAtEOF = false; zzCurrentPos = 0; zzMarkedPos = 0; zzStartRead = 0; zzEndRead = 0; zzFinalHighSurrogate = 0; yyline = 0; yycolumn = 0; yychar = 0L; } /** * Returns whether the scanner has reached the end of the reader it reads from. * * @return whether the scanner has reached EOF. */ public final boolean yyatEOF() { return zzAtEOF; } /** * Returns the current lexical state. * * @return the current lexical state. */ public final int yystate() { return zzLexicalState; } /** * Enters a new lexical state. * * @param newState the new lexical state */ public final void yybegin(int newState) { zzLexicalState = newState; } /** * Returns the text matched by the current regular expression. * * @return the matched text. */ public final String yytext() { return new String(zzBuffer, zzStartRead, zzMarkedPos-zzStartRead); } /** * Returns the character at the given position from the matched text. * *

It is equivalent to {@code yytext().charAt(pos)}, but faster. * * @param position the position of the character to fetch. A value from 0 to {@code yylength()-1}. * * @return the character at {@code position}. */ public final char yycharat(int position) { return zzBuffer[zzStartRead + position]; } /** * How many characters were matched. * * @return the length of the matched text region. */ public final int yylength() { return zzMarkedPos-zzStartRead; } /** * Reports an error that occurred while scanning. * *

In a well-formed scanner (no or only correct usage of {@code yypushback(int)} and a * match-all fallback rule) this method will only be called with things that * "Can't Possibly Happen". * *

If this method is called, something is seriously wrong (e.g. a JFlex bug producing a faulty * scanner etc.). * *

Usual syntax/scanner level error handling should be done in error fallback rules. * * @param errorCode the code of the error message to display. */ --- zzScanError declaration String message; try { message = ZZ_ERROR_MSG[errorCode]; } catch (ArrayIndexOutOfBoundsException e) { message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; } --- throws clause } /** * Pushes the specified amount of characters back into the input stream. * *

They will be read again by then next call of the scanning method. * * @param number the number of characters to be read again. This number must not be greater than * {@link #yylength()}. */ --- yypushback decl (contains zzScanError exception) if ( number > yylength() ) zzScanError(ZZ_PUSHBACK_2BIG); zzMarkedPos -= number; } --- zzDoEOF /** * Resumes scanning until the next regular expression is matched, the end of input is encountered * or an I/O-Error occurs. * * @return the next token. * @exception java.io.IOException if any I/O-Error occurs. */ --- yylex declaration int zzInput; int zzAction; // cached fields: int zzCurrentPosL; int zzMarkedPosL; int zzEndReadL = zzEndRead; char[] zzBufferL = zzBuffer; --- local declarations while (true) { zzMarkedPosL = zzMarkedPos; --- start admin (line, char, col count) zzAction = -1; zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; --- start admin (lexstate etc) zzForAction: { while (true) { --- next input, line, col, char count, next transition, isFinal action zzAction = zzState; zzMarkedPosL = zzCurrentPosL; --- line count update } } } // store back cached position zzMarkedPos = zzMarkedPosL; --- char count update if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { zzAtEOF = true; --- eofvalue } else { --- actions default: --- no match } } } } --- main }