ArdenBaseLexer.java

// $ANTLR 2.7.6 (2005-12-22): "ArdenRecognizer.g" -> "ArdenBaseLexer.java"$

package org.openmrs.arden;

import java.io.*;
import antlr.CommonAST;
import antlr.collections.AST;
import antlr.*;
import org.openmrs.arden.MLMObject;
import org.openmrs.arden.MLMObjectElement;
import java.lang.Integer;
import org.openmrs.logic.*;
import org.openmrs.logic.op.*;
import java.util.GregorianCalendar;

import java.io.InputStream;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.TokenStreamRecognitionException;
import antlr.CharStreamException;
import antlr.CharStreamIOException;
import antlr.ANTLRException;
import java.io.Reader;
import java.util.Hashtable;
import antlr.CharScanner;
import antlr.InputBuffer;
import antlr.ByteBuffer;
import antlr.CharBuffer;
import antlr.Token;
import antlr.CommonToken;
import antlr.RecognitionException;
import antlr.NoViableAltForCharException;
import antlr.MismatchedCharException;
import antlr.TokenStream;
import antlr.ANTLRHashString;
import antlr.LexerSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.SemanticException;

/*************************************************************************************/
public class ArdenBaseLexer extends antlr.CharScanner implements ArdenBaseParserTokenTypes, TokenStream {
	
	public ArdenBaseLexer(InputStream in) {
		this(new ByteBuffer(in));
	}
	
	public ArdenBaseLexer(Reader in) {
		this(new CharBuffer(in));
	}
	
	public ArdenBaseLexer(InputBuffer ib) {
		this(new LexerSharedInputState(ib));
	}
	
	public ArdenBaseLexer(LexerSharedInputState state) {
		super(state);
		caseSensitiveLiterals = false;
		setCaseSensitive(false);
		literals = new Hashtable();
		literals.put(new ANTLRHashString("PRESENT", this), new Integer(141));
		literals.put(new ANTLRHashString("filename", this), new Integer(69));
		literals.put(new ANTLRHashString("type", this), new Integer(82));
		literals.put(new ANTLRHashString("now", this), new Integer(23));
		literals.put(new ANTLRHashString("priority", this), new Integer(74));
		literals.put(new ANTLRHashString("LIST", this), new Integer(147));
		literals.put(new ANTLRHashString("before", this), new Integer(17));
		literals.put(new ANTLRHashString("CALL", this), new Integer(163));
		literals.put(new ANTLRHashString("action", this), new Integer(65));
		literals.put(new ANTLRHashString("time", this), new Integer(87));
		literals.put(new ANTLRHashString("call", this), new Integer(89));
		literals.put(new ANTLRHashString("expired", this), new Integer(114));
		literals.put(new ANTLRHashString("specialist", this), new Integer(76));
		literals.put(new ANTLRHashString("endif", this), new Integer(60));
		literals.put(new ANTLRHashString("end", this), new Integer(100));
		literals.put(new ANTLRHashString("production", this), new Integer(112));
		literals.put(new ANTLRHashString("months", this), new Integer(50));
		literals.put(new ANTLRHashString("+", this), new Integer(178));
		literals.put(new ANTLRHashString("STRING", this), new Integer(146));
		literals.put(new ANTLRHashString("are", this), new Integer(7));
		literals.put(new ANTLRHashString("purpose", this), new Integer(77));
		literals.put(new ANTLRHashString("maximum", this), new Integer(36));
		literals.put(new ANTLRHashString("exist", this), new Integer(44));
		literals.put(new ANTLRHashString("knowledge", this), new Integer(67));
		literals.put(new ANTLRHashString("NUMBER", this), new Integer(144));
		literals.put(new ANTLRHashString("seconds", this), new Integer(154));
		literals.put(new ANTLRHashString("author", this), new Integer(73));
		literals.put(new ANTLRHashString("where", this), new Integer(43));
		literals.put(new ANTLRHashString("lastest", this), new Integer(41));
		literals.put(new ANTLRHashString("maintenance", this), new Integer(66));
		literals.put(new ANTLRHashString("minutes", this), new Integer(153));
		literals.put(new ANTLRHashString("OCCUR", this), new Integer(155));
		literals.put(new ANTLRHashString("write", this), new Integer(20));
		literals.put(new ANTLRHashString("past", this), new Integer(46));
		literals.put(new ANTLRHashString("*", this), new Integer(180));
		literals.put(new ANTLRHashString("then", this), new Integer(32));
		literals.put(new ANTLRHashString("be", this), new Integer(24));
		literals.put(new ANTLRHashString("Occur", this), new Integer(156));
		literals.put(new ANTLRHashString("present", this), new Integer(96));
		literals.put(new ANTLRHashString("to", this), new Integer(91));
		literals.put(new ANTLRHashString("than", this), new Integer(15));
		literals.put(new ANTLRHashString("explanation", this), new Integer(78));
		literals.put(new ANTLRHashString("and", this), new Integer(4));
		literals.put(new ANTLRHashString("not", this), new Integer(30));
		literals.put(new ANTLRHashString("occurs", this), new Integer(159));
		literals.put(new ANTLRHashString("less", this), new Integer(12));
		literals.put(new ANTLRHashString("NULL", this), new Integer(142));
		literals.put(new ANTLRHashString("date", this), new Integer(83));
		literals.put(new ANTLRHashString("validation", this), new Integer(111));
		literals.put(new ANTLRHashString("evoke", this), new Integer(162));
		literals.put(new ANTLRHashString("month", this), new Integer(49));
		literals.put(new ANTLRHashString("from", this), new Integer(16));
		literals.put(new ANTLRHashString("null", this), new Integer(99));
		literals.put(new ANTLRHashString("age_min", this), new Integer(84));
		literals.put(new ANTLRHashString("they", this), new Integer(29));
		literals.put(new ANTLRHashString("count", this), new Integer(10));
		literals.put(new ANTLRHashString("last", this), new Integer(38));
		literals.put(new ANTLRHashString("GT", this), new Integer(167));
		literals.put(new ANTLRHashString("arden", this), new Integer(106));
		literals.put(new ANTLRHashString("the", this), new Integer(14));
		literals.put(new ANTLRHashString("citations", this), new Integer(80));
		literals.put(new ANTLRHashString("urgency", this), new Integer(173));
		literals.put(new ANTLRHashString("institution", this), new Integer(72));
		literals.put(new ANTLRHashString("http", this), new Integer(98));
		literals.put(new ANTLRHashString("event", this), new Integer(42));
		literals.put(new ANTLRHashString("minimum", this), new Integer(34));
		literals.put(new ANTLRHashString("REFUTE", this), new Integer(132));
		literals.put(new ANTLRHashString("title", this), new Integer(71));
		literals.put(new ANTLRHashString("was", this), new Integer(8));
		literals.put(new ANTLRHashString("with", this), new Integer(90));
		literals.put(new ANTLRHashString("links", this), new Integer(81));
		literals.put(new ANTLRHashString("it", this), new Integer(28));
		literals.put(new ANTLRHashString("library", this), new Integer(68));
		literals.put(new ANTLRHashString("weeks", this), new Integer(52));
		literals.put(new ANTLRHashString("SEQTO", this), new Integer(177));
		literals.put(new ANTLRHashString("elseif", this), new Integer(59));
		literals.put(new ANTLRHashString("version", this), new Integer(75));
		literals.put(new ANTLRHashString("occur", this), new Integer(95));
		literals.put(new ANTLRHashString("at", this), new Integer(21));
		literals.put(new ANTLRHashString("of", this), new Integer(86));
		literals.put(new ANTLRHashString("is", this), new Integer(6));
		literals.put(new ANTLRHashString("DURATION", this), new Integer(145));
		literals.put(new ANTLRHashString("OBJECT", this), new Integer(148));
		literals.put(new ANTLRHashString("logic", this), new Integer(64));
		literals.put(new ANTLRHashString("years", this), new Integer(26));
		literals.put(new ANTLRHashString("or", this), new Integer(31));
		literals.put(new ANTLRHashString("MERGE", this), new Integer(174));
		literals.put(new ANTLRHashString("GE", this), new Integer(169));
		literals.put(new ANTLRHashString("any", this), new Integer(92));
		literals.put(new ANTLRHashString("BOOLEAN", this), new Integer(143));
		literals.put(new ANTLRHashString("if", this), new Integer(27));
		literals.put(new ANTLRHashString("greater", this), new Integer(13));
		literals.put(new ANTLRHashString("age_max", this), new Integer(85));
		literals.put(new ANTLRHashString("DATA", this), new Integer(176));
		literals.put(new ANTLRHashString("min", this), new Integer(35));
		literals.put(new ANTLRHashString("ASTM-E", this), new Integer(107));
		literals.put(new ANTLRHashString("first", this), new Integer(39));
		literals.put(new ANTLRHashString("EQ", this), new Integer(165));
		literals.put(new ANTLRHashString("OCCURRED", this), new Integer(160));
		literals.put(new ANTLRHashString("days", this), new Integer(47));
		literals.put(new ANTLRHashString("data", this), new Integer(63));
		literals.put(new ANTLRHashString("second", this), new Integer(94));
		literals.put(new ANTLRHashString("hour", this), new Integer(150));
		literals.put(new ANTLRHashString("keywords", this), new Integer(79));
		literals.put(new ANTLRHashString("hours", this), new Integer(151));
		literals.put(new ANTLRHashString("OCCURS", this), new Integer(157));
		literals.put(new ANTLRHashString("number", this), new Integer(97));
		literals.put(new ANTLRHashString("SUPPORT", this), new Integer(131));
		literals.put(new ANTLRHashString("Occurred", this), new Integer(161));
		literals.put(new ANTLRHashString("false", this), new Integer(62));
		literals.put(new ANTLRHashString("exists", this), new Integer(45));
		literals.put(new ANTLRHashString("conclude", this), new Integer(57));
		literals.put(new ANTLRHashString("average", this), new Integer(54));
		literals.put(new ANTLRHashString("LT", this), new Integer(166));
		literals.put(new ANTLRHashString("/", this), new Integer(181));
		literals.put(new ANTLRHashString("research", this), new Integer(93));
		literals.put(new ANTLRHashString("mlmname", this), new Integer(70));
		literals.put(new ANTLRHashString("minute", this), new Integer(152));
		literals.put(new ANTLRHashString("were", this), new Integer(9));
		literals.put(new ANTLRHashString("day", this), new Integer(48));
		literals.put(new ANTLRHashString("data-driven", this), new Integer(135));
		literals.put(new ANTLRHashString("max", this), new Integer(37));
		literals.put(new ANTLRHashString("year", this), new Integer(25));
		literals.put(new ANTLRHashString("sum", this), new Integer(55));
		literals.put(new ANTLRHashString("after", this), new Integer(18));
		literals.put(new ANTLRHashString("SORT", this), new Integer(175));
		literals.put(new ANTLRHashString("else", this), new Integer(58));
		literals.put(new ANTLRHashString("in", this), new Integer(11));
		literals.put(new ANTLRHashString("let", this), new Integer(22));
		literals.put(new ANTLRHashString("ago", this), new Integer(19));
		literals.put(new ANTLRHashString("avg", this), new Integer(53));
		literals.put(new ANTLRHashString("data_driven", this), new Integer(136));
		literals.put(new ANTLRHashString("median", this), new Integer(56));
		literals.put(new ANTLRHashString("earliest", this), new Integer(40));
		literals.put(new ANTLRHashString("week", this), new Integer(51));
		literals.put(new ANTLRHashString("true", this), new Integer(61));
		literals.put(new ANTLRHashString("within", this), new Integer(88));
		literals.put(new ANTLRHashString("-", this), new Integer(179));
		literals.put(new ANTLRHashString("read", this), new Integer(33));
		literals.put(new ANTLRHashString("Occurs", this), new Integer(158));
		literals.put(new ANTLRHashString("testing", this), new Integer(113));
		literals.put(new ANTLRHashString("NE", this), new Integer(171));
		literals.put(new ANTLRHashString("LE", this), new Integer(168));
	}
	
	public Token nextToken() throws TokenStreamException {
		Token theRetToken = null;
		tryAgain: for (;;) {
			Token _token = null;
			int _ttype = Token.INVALID_TYPE;
			resetText();
			try { // for char stream error handling
				try { // for lexical error handling
					switch (LA(1)) {
						case '}': {
							mRCURLY(true);
							theRetToken = _returnToken;
							break;
						}
						case ',': {
							mCOMMA(true);
							theRetToken = _returnToken;
							break;
						}
						case ')': {
							mRPAREN(true);
							theRetToken = _returnToken;
							break;
						}
						case '"': {
							mSTRING_LITERAL(true);
							theRetToken = _returnToken;
							break;
						}
						case '\t':
						case '\n':
						case '\u000c':
						case '\r':
						case ' ': {
							mWS(true);
							theRetToken = _returnToken;
							break;
						}
						case 'A':
						case 'B':
						case 'C':
						case 'D':
						case 'E':
						case 'F':
						case 'G':
						case 'H':
						case 'I':
						case 'J':
						case 'K':
						case 'L':
						case 'M':
						case 'N':
						case 'O':
						case 'P':
						case 'Q':
						case 'R':
						case 'S':
						case 'T':
						case 'U':
						case 'V':
						case 'W':
						case 'X':
						case 'Y':
						case 'Z':
						case 'a':
						case 'b':
						case 'c':
						case 'd':
						case 'e':
						case 'f':
						case 'g':
						case 'h':
						case 'i':
						case 'j':
						case 'k':
						case 'l':
						case 'm':
						case 'n':
						case 'o':
						case 'p':
						case 'q':
						case 'r':
						case 's':
						case 't':
						case 'u':
						case 'v':
						case 'w':
						case 'x':
						case 'y':
						case 'z': {
							mID(true);
							theRetToken = _returnToken;
							break;
						}
						case '-': {
							mMINUS(true);
							theRetToken = _returnToken;
							break;
						}
						case '_': {
							mUNDERSCORE(true);
							theRetToken = _returnToken;
							break;
						}
						case '@': {
							mAT(true);
							theRetToken = _returnToken;
							break;
						}
						case '=': {
							mEQUALS(true);
							theRetToken = _returnToken;
							break;
						}
						case '[': {
							mLBRACKET(true);
							theRetToken = _returnToken;
							break;
						}
						case ']': {
							mRBRACKET(true);
							theRetToken = _returnToken;
							break;
						}
						case '+': {
							mPLUS(true);
							theRetToken = _returnToken;
							break;
						}
						case '*': {
							mTIMES(true);
							theRetToken = _returnToken;
							break;
						}
						case '&': {
							mAMPERSAND(true);
							theRetToken = _returnToken;
							break;
						}
						case '%': {
							mPERCENT(true);
							theRetToken = _returnToken;
							break;
						}
						case '#': {
							mPOUND(true);
							theRetToken = _returnToken;
							break;
						}
						case '?': {
							mQUESTION(true);
							theRetToken = _returnToken;
							break;
						}
						case '|': {
							mACTION_OP(true);
							theRetToken = _returnToken;
							break;
						}
						default:
							if ((LA(1) == '{') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff'))) {
								mARDEN_CURLY_BRACKETS(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == ':') && (LA(2) == '/')) {
								mNOT_COMMENT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '/') && (LA(2) == '/')) {
								mCOMMENT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '/') && (LA(2) == '*')) {
								mML_COMMENT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == ':') && (LA(2) == '=')) {
								mBECOMES(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '.') && (LA(2) == '.')) {
								mDOTDOT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '/') && (LA(2) == '=')) {
								mNOT_EQUALS(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '<') && (LA(2) == '=')) {
								mLTE(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '>') && (LA(2) == '=')) {
								mGTE(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '<') && (LA(2) == '>')) {
								mNE(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == ';') && (LA(2) == ';')) {
								mENDBLOCK(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '{') && (true)) {
								mLCURLY(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '(') && (true)) {
								mLPAREN(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '\'') && (true)) {
								mTERM_LITERAL(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '.') && (true)) {
								mDOT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '/') && (true)) {
								mDIV(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == ':') && (true)) {
								mCOLON(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == ';') && (true)) {
								mSEMI(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '<') && (true)) {
								mLT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '>') && (true)) {
								mGT(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '\'') && (true)) {
								mAPOSTROPHE(true);
								theRetToken = _returnToken;
							} else if ((LA(1) == '\'') && (true)) {
								mSINGLE_QUOTE(true);
								theRetToken = _returnToken;
							} else {
								mINTLIT(true);
								theRetToken = _returnToken;
							}
					}
					if (_returnToken == null)
						continue tryAgain; // found SKIP token
					_ttype = _returnToken.getType();
					_returnToken.setType(_ttype);
					return _returnToken;
				}
				catch (RecognitionException e) {
					throw new TokenStreamRecognitionException(e);
				}
			}
			catch (CharStreamException cse) {
				if (cse instanceof CharStreamIOException) {
					throw new TokenStreamIOException(((CharStreamIOException) cse).io);
				} else {
					throw new TokenStreamException(cse.getMessage());
				}
			}
		}
	}
	
	public final void mARDEN_CURLY_BRACKETS(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ARDEN_CURLY_BRACKETS;
		int _saveIndex;
		
		mLCURLY(false);
		{
			_loop606: do {
				// nongreedy exit test
				if ((LA(1) == '}') && (true))
					break _loop606;
				if (((LA(1) >= '\u0000' && LA(1) <= '\u00ff')) && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff'))) {
					matchNot(EOF_CHAR);
				} else {
					break _loop606;
				}
				
			} while (true);
		}
		mRCURLY(false);
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LCURLY;
		int _saveIndex;
		
		match('{');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = RCURLY;
		int _saveIndex;
		
		match('}');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mNOT_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = NOT_COMMENT;
		int _saveIndex;
		
		match("://");
		{
			_loop610: do {
				if ((_tokenSet_0.member(LA(1)))) {
					{
						match(_tokenSet_0);
					}
				} else {
					break _loop610;
				}
				
			} while (true);
		}
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMENT;
		int _saveIndex;
		
		match("//");
		{
			_loop614: do {
				if ((_tokenSet_1.member(LA(1)))) {
					{
						match(_tokenSet_1);
					}
				} else {
					break _loop614;
				}
				
			} while (true);
		}
		_ttype = Token.SKIP;
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ML_COMMENT;
		int _saveIndex;
		
		match("/*");
		{
			_loop618: do {
				if (((LA(1) == '*') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff'))) && (LA(2) != '/')) {
					match('*');
				} else if ((LA(1) == '\r') && (LA(2) == '\n')) {
					match('\r');
					match('\n');
					newline();
				} else if ((LA(1) == '\r') && ((LA(2) >= '\u0000' && LA(2) <= '\u00ff'))) {
					match('\r');
					newline();
				} else if ((LA(1) == '\n')) {
					match('\n');
					newline();
				} else if ((_tokenSet_2.member(LA(1)))) {
					{
						match(_tokenSet_2);
					}
				} else {
					break _loop618;
				}
				
			} while (true);
		}
		match("*/");
		_ttype = Token.SKIP;
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = DIGIT;
		int _saveIndex;
		
		matchRange('0', '9');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mINTLIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = INTLIT;
		int _saveIndex;
		
		{
			{
				_loop626: do {
					if (((LA(1) >= '0' && LA(1) <= '9'))) {
						{
							int _cnt624 = 0;
							_loop624: do {
								if (((LA(1) >= '0' && LA(1) <= '9')) && (true)) {
									mDIGIT(false);
								} else {
									if (_cnt624 >= 1) {
										break _loop624;
									} else {
										throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(),
										        getColumn());
									}
								}
								
								_cnt624++;
							} while (true);
						}
						{
							if ((LA(1) == ',')) {
								mCOMMA(false);
							} else {}
							
						}
					} else {
						break _loop626;
					}
					
				} while (true);
			}
			{
				if ((LA(1) == '(')) {
					{
						mLPAREN(false);
						{
							int _cnt630 = 0;
							_loop630: do {
								if (((LA(1) >= '0' && LA(1) <= '9'))) {
									mDIGIT(false);
								} else {
									if (_cnt630 >= 1) {
										break _loop630;
									} else {
										throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(),
										        getColumn());
									}
								}
								
								_cnt630++;
							} while (true);
						}
						mRPAREN(false);
					}
				} else {}
				
			}
		}
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMA;
		int _saveIndex;
		
		match(',');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LPAREN;
		int _saveIndex;
		
		match('(');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = RPAREN;
		int _saveIndex;
		
		match(')');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = STRING_LITERAL;
		int _saveIndex;
		
		_saveIndex = text.length();
		match('"');
		text.setLength(_saveIndex);
		{
			_loop634: do {
				if ((LA(1) == '"') && (LA(2) == '"')) {
					match('"');
					_saveIndex = text.length();
					match('"');
					text.setLength(_saveIndex);
				} else if ((_tokenSet_3.member(LA(1)))) {
					{
						match(_tokenSet_3);
					}
				} else {
					break _loop634;
				}
				
			} while (true);
		}
		{
			if ((LA(1) == '"')) {
				_saveIndex = text.length();
				match('"');
				text.setLength(_saveIndex);
			} else {}
			
		}
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mTERM_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = TERM_LITERAL;
		int _saveIndex;
		
		_saveIndex = text.length();
		match('\'');
		text.setLength(_saveIndex);
		{
			_loop639: do {
				if ((LA(1) == '\'') && (LA(2) == '\'')) {
					match('\'');
					_saveIndex = text.length();
					match('\'');
					text.setLength(_saveIndex);
				} else if ((_tokenSet_4.member(LA(1)))) {
					{
						match(_tokenSet_4);
					}
				} else {
					break _loop639;
				}
				
			} while (true);
		}
		{
			if ((LA(1) == '\'')) {
				_saveIndex = text.length();
				match('\'');
				text.setLength(_saveIndex);
			} else {}
			
		}
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = WS;
		int _saveIndex;
		
		{
			switch (LA(1)) {
				case ' ': {
					match(' ');
					break;
				}
				case '\t': {
					match('\t');
					break;
				}
				case '\u000c': {
					match('\f');
					break;
				}
				case '\n':
				case '\r': {
					{
						if ((LA(1) == '\r') && (LA(2) == '\n')) {
							match("\r\n");
						} else if ((LA(1) == '\r') && (true)) {
							match('\r');
						} else if ((LA(1) == '\n')) {
							match('\n');
						} else {
							throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
						}
						
					}
					newline();
					break;
				}
				default: {
					throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
				}
			}
		}
		_ttype = Token.SKIP;
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ID;
		int _saveIndex;
		
		{
			{
				switch (LA(1)) {
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z': {
						matchRange('a', 'z');
						break;
					}
					case 'A':
					case 'B':
					case 'C':
					case 'D':
					case 'E':
					case 'F':
					case 'G':
					case 'H':
					case 'I':
					case 'J':
					case 'K':
					case 'L':
					case 'M':
					case 'N':
					case 'O':
					case 'P':
					case 'Q':
					case 'R':
					case 'S':
					case 'T':
					case 'U':
					case 'V':
					case 'W':
					case 'X':
					case 'Y':
					case 'Z': {
						matchRange('A', 'Z');
						break;
					}
					default: {
						throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
					}
				}
			}
			{
				_loop648: do {
					switch (LA(1)) {
						case 'a':
						case 'b':
						case 'c':
						case 'd':
						case 'e':
						case 'f':
						case 'g':
						case 'h':
						case 'i':
						case 'j':
						case 'k':
						case 'l':
						case 'm':
						case 'n':
						case 'o':
						case 'p':
						case 'q':
						case 'r':
						case 's':
						case 't':
						case 'u':
						case 'v':
						case 'w':
						case 'x':
						case 'y':
						case 'z': {
							matchRange('a', 'z');
							break;
						}
						case 'A':
						case 'B':
						case 'C':
						case 'D':
						case 'E':
						case 'F':
						case 'G':
						case 'H':
						case 'I':
						case 'J':
						case 'K':
						case 'L':
						case 'M':
						case 'N':
						case 'O':
						case 'P':
						case 'Q':
						case 'R':
						case 'S':
						case 'T':
						case 'U':
						case 'V':
						case 'W':
						case 'X':
						case 'Y':
						case 'Z': {
							matchRange('A', 'Z');
							break;
						}
						case '0':
						case '1':
						case '2':
						case '3':
						case '4':
						case '5':
						case '6':
						case '7':
						case '8':
						case '9': {
							matchRange('0', '9');
							break;
						}
						case '-': {
							mMINUS(false);
							break;
						}
						case ',': {
							mCOMMA(false);
							break;
						}
						case '.': {
							mDOT(false);
							break;
						}
						case '/': {
							mDIV(false);
							break;
						}
						case '_': {
							mUNDERSCORE(false);
							break;
						}
						case '@': {
							mAT(false);
							break;
						}
						default: {
							break _loop648;
						}
					}
				} while (true);
			}
		}
		_ttype = testLiteralsTable(_ttype);
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = MINUS;
		int _saveIndex;
		
		match('-');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = DOT;
		int _saveIndex;
		
		match('.');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = DIV;
		int _saveIndex;
		
		match('/');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mUNDERSCORE(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = UNDERSCORE;
		int _saveIndex;
		
		match("_");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = AT;
		int _saveIndex;
		
		match("@");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mBECOMES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = BECOMES;
		int _saveIndex;
		
		match(":=");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COLON;
		int _saveIndex;
		
		match(':');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = SEMI;
		int _saveIndex;
		
		match(';');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mEQUALS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = EQUALS;
		int _saveIndex;
		
		match('=');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mLBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LBRACKET;
		int _saveIndex;
		
		match('[');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mRBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = RBRACKET;
		int _saveIndex;
		
		match(']');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mDOTDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = DOTDOT;
		int _saveIndex;
		
		match("..");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mNOT_EQUALS(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = NOT_EQUALS;
		int _saveIndex;
		
		match("/=");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LT;
		int _saveIndex;
		
		match('<');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mLTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LTE;
		int _saveIndex;
		
		match("<=");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = GT;
		int _saveIndex;
		
		match('>');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mGTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = GTE;
		int _saveIndex;
		
		match(">=");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = PLUS;
		int _saveIndex;
		
		match('+');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mTIMES(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = TIMES;
		int _saveIndex;
		
		match('*');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mNE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = NE;
		int _saveIndex;
		
		match("<>");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mAPOSTROPHE(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = APOSTROPHE;
		int _saveIndex;
		
		match('\'');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mAMPERSAND(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = AMPERSAND;
		int _saveIndex;
		
		match('&');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mPERCENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = PERCENT;
		int _saveIndex;
		
		match('%');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mPOUND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = POUND;
		int _saveIndex;
		
		match('#');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = QUESTION;
		int _saveIndex;
		
		match('?');
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mENDBLOCK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ENDBLOCK;
		int _saveIndex;
		
		match(";;");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mACTION_OP(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ACTION_OP;
		int _saveIndex;
		
		match("||");
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	public final void mSINGLE_QUOTE(boolean _createToken) throws RecognitionException, CharStreamException,
	        TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = SINGLE_QUOTE;
		int _saveIndex;
		
		_saveIndex = text.length();
		match('\'');
		text.setLength(_saveIndex);
		if (_createToken && _token == null && _ttype != Token.SKIP) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}
	
	private static final long[] mk_tokenSet_0() {
		long[] data = new long[8];
		data[0] = -576460752303432705L;
		for (int i = 1; i <= 3; i++) {
			data[i] = -1L;
		}
		return data;
	}
	
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	
	private static final long[] mk_tokenSet_1() {
		long[] data = new long[8];
		data[0] = -9217L;
		for (int i = 1; i <= 3; i++) {
			data[i] = -1L;
		}
		return data;
	}
	
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
	
	private static final long[] mk_tokenSet_2() {
		long[] data = new long[8];
		data[0] = -4398046520321L;
		for (int i = 1; i <= 3; i++) {
			data[i] = -1L;
		}
		return data;
	}
	
	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
	
	private static final long[] mk_tokenSet_3() {
		long[] data = new long[8];
		data[0] = -17179878401L;
		for (int i = 1; i <= 3; i++) {
			data[i] = -1L;
		}
		return data;
	}
	
	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
	
	private static final long[] mk_tokenSet_4() {
		long[] data = new long[8];
		data[0] = -549755823105L;
		for (int i = 1; i <= 3; i++) {
			data[i] = -1L;
		}
		return data;
	}
	
	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
	
}