/** this character denotes the end of file */ | |
final public static int YYEOF = -1; | |
/** lexical states */ | |
--- lexical states, charmap | |
/* error codes */ | |
final private static int YY_UNKNOWN_ERROR = 0; | |
final private static int YY_ILLEGAL_STATE = 1; | |
final private static int YY_NO_MATCH = 2; | |
final private static int YY_PUSHBACK_2BIG = 3; | |
/* error messages for the codes above */ | |
final private static String YY_ERROR_MSG[] = { | |
"Unkown internal scanner error", //$NON-NLS-1$ | |
"Internal error: unknown state", //$NON-NLS-1$ | |
"Error: could not match input", //$NON-NLS-1$ | |
"Error: pushback value was too large" //$NON-NLS-1$ | |
}; | |
--- isFinal list | |
/** the input device */ | |
private java.io.Reader yy_reader; | |
/** the current state of the DFA */ | |
private int yy_state; | |
/** the current lexical state */ | |
private int yy_lexical_state = YYINITIAL; | |
/** this buffer contains the current text to be matched and is | |
the source of the yytext() string */ | |
private char yy_buffer[] = new char[16384]; | |
/** the textposition at the last accepting state */ | |
private int yy_markedPos; | |
/** the textposition at the last state to be included in yytext */ | |
private int yy_pushbackPos; | |
/** the current text position in the buffer */ | |
private int yy_currentPos; | |
/** startRead marks the beginning of the yytext() string in the buffer */ | |
private int yy_startRead; | |
/** endRead marks the last character in the buffer, that has been read | |
from input */ | |
private int yy_endRead; | |
/** number of newlines encountered up to the start of the matched text */ | |
private int yyline; | |
/** the number of characters up to the start of the matched text */ | |
private int yychar; | |
/** yy_atEOF == true <=> the scanner has returned a value for EOF */ | |
private boolean yy_atEOF; | |
// state stack for handling embedded regions | |
private IntStack fStateStack = new IntStack(); | |
--- user class code | |
/** | |
* Creates a new scanner | |
* There is also a java.io.InputStream version of this constructor. | |
* | |
* @param in the java.io.Reader to read input from. | |
*/ | |
--- constructor declaration | |
/** | |
* Gets the next input character. | |
* | |
* @return the next character of the input stream, EOF if the | |
* end of the stream is reached. | |
* @exception IOException if any I/O-Error occurs | |
*/ | |
private int yy_advance() throws java.io.IOException { | |
/* standard case */ | |
if (yy_currentPos < yy_endRead) return yy_buffer[yy_currentPos++]; | |
/* if the eof is reached, we don't need to work hard */ | |
if (yy_atEOF) return YYEOF; | |
/* otherwise: need to refill the buffer */ | |
/* first: make room (if you can) */ | |
if (yy_startRead > 0) { | |
System.arraycopy(yy_buffer, yy_startRead, | |
yy_buffer, 0, | |
yy_endRead-yy_startRead); | |
/* translate stored positions */ | |
yy_endRead-= yy_startRead; | |
yy_currentPos-= yy_startRead; | |
yy_markedPos-= yy_startRead; | |
yy_pushbackPos-= yy_startRead; | |
yy_startRead = 0; | |
} | |
/* is the buffer big enough? */ | |
if (yy_currentPos >= yy_buffer.length) { | |
/* if not: blow it up */ | |
char newBuffer[] = new char[yy_currentPos*2]; | |
System.arraycopy(yy_buffer, 0, newBuffer, 0, yy_buffer.length); | |
yy_buffer = newBuffer; | |
} | |
/* finally: fill the buffer with new input */ | |
int numRead = yy_reader.read(yy_buffer, yy_endRead, | |
yy_buffer.length-yy_endRead); | |
if ( numRead == -1 ) return YYEOF; | |
yy_endRead+= numRead; | |
return yy_buffer[yy_currentPos++]; | |
} | |
/** | |
* Closes the input stream. | |
*/ | |
final public void yyclose() throws java.io.IOException { | |
yy_atEOF = true; /* indicate end of file */ | |
yy_endRead = yy_startRead; /* invalidate buffer */ | |
yy_reader.close(); | |
} | |
/** | |
* Returns the current lexical state. | |
*/ | |
final public int yystate() { | |
return yy_lexical_state; | |
} | |
/** | |
* Enters a new lexical state | |
* | |
* @param newState the new lexical state | |
*/ | |
final public void yybegin(int newState) { | |
yy_lexical_state = newState; | |
} | |
/** | |
* Returns the text matched by the current regular expression. | |
*/ | |
final public String yytext() { | |
return new String( yy_buffer, yy_startRead, yy_markedPos-yy_startRead ); | |
} | |
/** | |
* Returns the length of the matched text region. | |
*/ | |
final public int yylength() { | |
return yy_markedPos-yy_startRead; | |
} | |
/** | |
* Reports an error that occured while scanning - from the SED JFlex skeleton | |
* | |
* @param errorCode the code of the errormessage to display | |
*/ | |
private void yy_ScanError(int errorCode) { | |
try { | |
//Logger.log(Logger.ERROR, YY_ERROR_MSG[errorCode]); | |
System.out.println("ScanError: " + errorCode + ": " + YY_ERROR_MSG[errorCode]); | |
} | |
catch (ArrayIndexOutOfBoundsException e) { | |
//Logger.log(Logger.ERROR, YY_ERROR_MSG[YY_UNKNOWN_ERROR]); | |
System.out.println("ScanError: " + errorCode + ": " + YY_ERROR_MSG[YY_UNKNOWN_ERROR]); | |
} | |
// DO NOT EXIT the VM on an error | |
// System.exit(1); | |
} | |
/** | |
* 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 yylength()! | |
*/ | |
private void yypushback(int number) { | |
if ( number > yylength() ) | |
yy_ScanError(YY_PUSHBACK_2BIG); | |
yy_markedPos -= number; | |
} | |
--- yy_doEof | |
/** | |
* 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 IOException if any I/O-Error occurs | |
*/ | |
--- yylex declaration | |
int yy_input; | |
int yy_action; | |
--- local declarations | |
while (true) { | |
--- start admin (line, char, col count) | |
yy_action = -1; | |
yy_currentPos = yy_startRead = yy_markedPos; | |
--- start admin (lexstate etc) | |
yy_forAction: { | |
while (true) { | |
yy_input = yy_advance(); | |
if ( yy_input == YYEOF ) break yy_forAction; | |
--- line, col, char count, next transition, isFinal action | |
yy_action = yy_state; | |
yy_markedPos = yy_currentPos; | |
--- line count update | |
} | |
} | |
} | |
--- char count update | |
switch (yy_action) { | |
--- actions | |
default: | |
if (yy_input == YYEOF && yy_startRead == yy_currentPos) { | |
yy_atEOF = true; | |
--- eofvalue | |
} | |
else { | |
--- no match | |
} | |
} | |
} | |
} | |
--- main | |
} |