/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
*/

// ANTLR GENERATED CODE: DO NOT EDIT (LUCENENET: Not really auto generated in the port)

using System;
#if FEATURE_SERIALIZABLE_EXCEPTIONS
using System.Runtime.Serialization;
#endif
using Antlr.Runtime;

namespace Lucene.Net.Expressions.JS
{
	internal class JavascriptLexer : Lexer
	{
		public const int EOF = -1;

		public const int AT_ADD = 4;

		public const int AT_BIT_AND = 5;

		public const int AT_BIT_NOT = 6;

		public const int AT_BIT_OR = 7;

		public const int AT_BIT_SHL = 8;

		public const int AT_BIT_SHR = 9;

		public const int AT_BIT_SHU = 10;

		public const int AT_BIT_XOR = 11;

		public const int AT_BOOL_AND = 12;

		public const int AT_BOOL_NOT = 13;

		public const int AT_BOOL_OR = 14;

		public const int AT_CALL = 15;

		public const int AT_COLON = 16;

		public const int AT_COMMA = 17;

		public const int AT_COMP_EQ = 18;

		public const int AT_COMP_GT = 19;

		public const int AT_COMP_GTE = 20;

		public const int AT_COMP_LT = 21;

		public const int AT_COMP_LTE = 22;

		public const int AT_COMP_NEQ = 23;

		public const int AT_COND_QUE = 24;

		public const int AT_DIVIDE = 25;

		public const int AT_DOT = 26;

		public const int AT_LPAREN = 27;

		public const int AT_MODULO = 28;

		public const int AT_MULTIPLY = 29;

		public const int AT_NEGATE = 30;

		public const int AT_RPAREN = 31;

		public const int AT_SUBTRACT = 32;

		public const int DECIMAL = 33;

		public const int DECIMALDIGIT = 34;

		public const int DECIMALINTEGER = 35;

		public const int EXPONENT = 36;

		public const int HEX = 37;

		public const int HEXDIGIT = 38;

		public const int ID = 39;

		public const int NAMESPACE_ID = 40;

		public const int OCTAL = 41;

		public const int OCTALDIGIT = 42;

		public const int WS = 43;

		public override void DisplayRecognitionError(string[] tokenNames, RecognitionException re)
		{
			string message = " unexpected character '" + (char)re.Character + "' at position (" + re.CharPositionInLine + ").";
			ParseException parseException = new ParseException(message, re.CharPositionInLine);
			
			throw new InvalidOperationException(parseException.Message, parseException);
		}

		// delegates
		// delegators
		public virtual Lexer[] GetDelegates()
		{
			return new Lexer[] {  };
		}

		public JavascriptLexer()
		{
			m_dfa9 = new JavascriptLexer.DFA9(this, this);
		}

		public JavascriptLexer(ICharStream input) : this(input, new RecognizerSharedState(
			))
		{
			m_dfa9 = new JavascriptLexer.DFA9(this, this);
		}

		public JavascriptLexer(ICharStream input, RecognizerSharedState state) : base(input
			, state)
		{
			m_dfa9 = new JavascriptLexer.DFA9(this, this);
		}

		public override string GrammarFileName
		{
		    get { return ""; }
		}

		// $ANTLR start "AT_ADD"
		
		public void MAT_ADD()
		{
			try
			{
				int _type = AT_ADD;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:25:8: ( '+' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:25:10: '+'
					Match('+');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_ADD"
        // $ANTLR start "AT_BIT_AND"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_AND()
		{
		    int _type = AT_BIT_AND;
		    int _channel = TokenChannels.Default;
		    {
		        // src/java/org/apache/lucene/expressions/js/Javascript.g:26:12: ( '&' )
		        // src/java/org/apache/lucene/expressions/js/Javascript.g:26:14: '&'
		        Match('&');
		    }
		    state.type = _type;
		    state.channel = _channel;
		}

        // do for sure before leaving
        // $ANTLR end "AT_BIT_AND"
        // $ANTLR start "AT_BIT_NOT"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_NOT()
		{
			try
			{
				int _type = AT_BIT_NOT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:27:12: ( '~' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:27:14: '~'
					Match('~');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BIT_NOT"
        // $ANTLR start "AT_BIT_OR"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_OR()
		{
			try
			{
				int _type = AT_BIT_OR;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:28:11: ( '|' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:28:13: '|'
					Match('|');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BIT_OR"
        // $ANTLR start "AT_BIT_SHL"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_SHL()
		{
			try
			{
				int _type = AT_BIT_SHL;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:29:12: ( '<<' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:29:14: '<<'
					Match("<<");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BIT_SHL"
        // $ANTLR start "AT_BIT_SHR"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_SHR()
		{
			try
			{
				int _type = AT_BIT_SHR;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:30:12: ( '>>' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:30:14: '>>'
					Match(">>");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BIT_SHR"
        // $ANTLR start "AT_BIT_SHU"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BIT_SHU()
		{
			try
			{
				int _type = AT_BIT_SHU;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:31:12: ( '>>>' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:31:14: '>>>'
					Match(">>>");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_BIT_SHU"
		// $ANTLR start "AT_BIT_XOR"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MAT_BIT_XOR()
		{
			try
			{
				int _type = AT_BIT_XOR;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:32:12: ( '^' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:32:14: '^'
					Match('^');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_BIT_XOR"
		// $ANTLR start "AT_BOOL_AND"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MAT_BOOL_AND()
		{
			try
			{
				int _type = AT_BOOL_AND;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:33:13: ( '&&' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:33:15: '&&'
					Match("&&");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BOOL_AND"
        // $ANTLR start "AT_BOOL_NOT"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BOOL_NOT()
		{
			try
			{
				int _type = AT_BOOL_NOT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:34:13: ( '!' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:34:15: '!'
					Match('!');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BOOL_NOT"
        // $ANTLR start "AT_BOOL_OR"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_BOOL_OR()
		{
			try
			{
				int _type = AT_BOOL_OR;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:35:12: ( '||' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:35:14: '||'
					Match("||");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_BOOL_OR"
        // $ANTLR start "AT_COLON"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COLON()
		{
			try
			{
				int _type = AT_COLON;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:36:10: ( ':' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:36:12: ':'
					Match(':');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COLON"
        // $ANTLR start "AT_COMMA"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMMA()
		{
			try
			{
				int _type = AT_COMMA;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:37:10: ( ',' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:37:12: ','
					Match(',');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMMA"
        // $ANTLR start "AT_COMP_EQ"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_EQ()
		{
			try
			{
				int _type = AT_COMP_EQ;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:38:12: ( '==' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:38:14: '=='
					Match("==");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_EQ"
        // $ANTLR start "AT_COMP_GT"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_GT()
		{
			try
			{
				int _type = AT_COMP_GT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:39:12: ( '>' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:39:14: '>'
					Match('>');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_GT"
        // $ANTLR start "AT_COMP_GTE"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_GTE()
		{
			try
			{
				int _type = AT_COMP_GTE;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:40:13: ( '>=' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:40:15: '>='
					Match(">=");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_GTE"
        // $ANTLR start "AT_COMP_LT"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_LT()
		{
			try
			{
				int _type = AT_COMP_LT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:41:12: ( '<' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:41:14: '<'
					Match('<');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_LT"
        // $ANTLR start "AT_COMP_LTE"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_LTE()
		{
			try
			{
				int _type = AT_COMP_LTE;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:42:13: ( '<=' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:42:15: '<='
					Match("<=");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_LTE"
        // $ANTLR start "AT_COMP_NEQ"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COMP_NEQ()
		{
			try
			{
				int _type = AT_COMP_NEQ;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:43:13: ( '!=' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:43:15: '!='
					Match("!=");
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COMP_NEQ"
        // $ANTLR start "AT_COND_QUE"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_COND_QUE()
		{
			try
			{
				int _type = AT_COND_QUE;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:44:13: ( '?' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:44:15: '?'
					Match('?');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_COND_QUE"
        // $ANTLR start "AT_DIVIDE"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_DIVIDE()
		{
			try
			{
				int _type = AT_DIVIDE;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:45:11: ( '/' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:45:13: '/'
					Match('/');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_DIVIDE"
        // $ANTLR start "AT_DOT"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_DOT()
		{
			try
			{
				int _type = AT_DOT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:46:8: ( '.' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:46:10: '.'
					Match('.');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_DOT"
        // $ANTLR start "AT_LPAREN"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_LPAREN()
		{
			try
			{
				int _type = AT_LPAREN;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:47:11: ( '(' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:47:13: '('
					Match('(');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_LPAREN"
		// $ANTLR start "AT_MODULO"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MAT_MODULO()
		{
			try
			{
				int _type = AT_MODULO;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:48:11: ( '%' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:48:13: '%'
					Match('%');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

        // do for sure before leaving
        // $ANTLR end "AT_MODULO"
        // $ANTLR start "AT_MULTIPLY"
        /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
        public void MAT_MULTIPLY()
		{
			try
			{
				int _type = AT_MULTIPLY;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:49:13: ( '*' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:49:15: '*'
					Match('*');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_MULTIPLY"
		// $ANTLR start "AT_RPAREN"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MAT_RPAREN()
		{
			try
			{
				int _type = AT_RPAREN;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:50:11: ( ')' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:50:13: ')'
					Match(')');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_RPAREN"
		// $ANTLR start "AT_SUBTRACT"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MAT_SUBTRACT()
		{
			try
			{
				int _type = AT_SUBTRACT;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:51:13: ( '-' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:51:15: '-'
					Match('-');
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "AT_SUBTRACT"
		// $ANTLR start "NAMESPACE_ID"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MNAMESPACE_ID()
		{
			try
			{
				int _type = NAMESPACE_ID;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:334:5: ( ID ( AT_DOT ID )* )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:334:7: ID ( AT_DOT ID )*
					MID();
					// src/java/org/apache/lucene/expressions/js/Javascript.g:334:10: ( AT_DOT ID )*
					while (true)
					{
						int alt1 = 2;
						int LA1_0 = input.LA(1);
						if ((LA1_0 == '.'))
						{
							alt1 = 1;
						}
						switch (alt1)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:334:11: AT_DOT ID
								MAT_DOT();
								MID();
								break;
							}

							default:
							{
								goto loop1_break;
							}
						}
//loop1_continue: ; // LUCENENET NOTE: Not used
					}
loop1_break: ;
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "NAMESPACE_ID"
		// $ANTLR start "ID"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MID()
		{
			try
			{
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:340:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:340:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
					if ((input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA
						(1) >= 'a' && input.LA(1) <= 'z'))
					{
						input.Consume();
					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null, input);
						Recover(mse);
						throw mse;
					}
					// src/java/org/apache/lucene/expressions/js/Javascript.g:340:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
					while (true)
					{
						int alt2 = 2;
						int LA2_0 = input.LA(1);
						if (((LA2_0 >= '0' && LA2_0 <= '9') || (LA2_0 >= 'A' && LA2_0 <= 'Z') || LA2_0 ==
							 '_' || (LA2_0 >= 'a' && LA2_0 <= 'z')))
						{
							alt2 = 1;
						}
						switch (alt2)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:
								if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
									(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z'))
								{
									input.Consume();
								}
								else
								{
									MismatchedSetException mse = new MismatchedSetException(null, input);
									Recover(mse);
									throw mse;
								}
								break;
							}

							default:
							{
								goto loop2_break;
							}
						}
//loop2_continue: ; // LUCENENET NOTE: Not used
					}
loop2_break: ;
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "ID"
		// $ANTLR start "WS"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MWS()
		{
			try
			{
				int _type = WS;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:343:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:343:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
					// src/java/org/apache/lucene/expressions/js/Javascript.g:343:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
					int cnt3 = 0;
					while (true)
					{
						int alt3 = 2;
						int LA3_0 = input.LA(1);
						if (((LA3_0 >= '\t' && LA3_0 <= '\n') || LA3_0 == '\r' || LA3_0 == ' '))
						{
							alt3 = 1;
						}
						switch (alt3)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:
								if ((input.LA(1) >= '\t' && input.LA(1) <= '\n') || input.LA(1) == '\r' || input.
									LA(1) == ' ')
								{
									input.Consume();
								}
								else
								{
									MismatchedSetException mse = new MismatchedSetException(null, input);
									Recover(mse);
									throw mse;
								}
								break;
							}

							default:
							{
								if (cnt3 >= 1)
								{
									goto loop3_break;
								}
								EarlyExitException eee = new EarlyExitException(3, input);
								throw eee;
							}
						}
						cnt3++;
                        //loop3_continue: ; // LUCENENET NOTE: Not used
                    }
                    loop3_break: ;
					Skip();
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "WS"
		// $ANTLR start "DECIMAL"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MDECIMAL()
		{
		    try
		    {
		        int type = DECIMAL;
		        int channel = TokenChannels.Default;
		        // src/java/org/apache/lucene/expressions/js/Javascript.g:347:5: ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? )
		        int alt9 = 3;
		        alt9 = m_dfa9.Predict(input);
		        switch (alt9)
		        {
		            case 1:
		            {
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:7: DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )?
		                MDECIMALINTEGER();
		                MAT_DOT();
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:29: ( DECIMALDIGIT )*
		                while (true)
		                {
		                    int alt4 = 2;
		                    int LA4_0 = input.LA(1);
		                    if (((LA4_0 >= '0' && LA4_0 <= '9')))
		                    {
		                        alt4 = 1;
		                    }
		                    switch (alt4)
		                    {
		                        case 1:
		                        {
		                            // src/java/org/apache/lucene/expressions/js/Javascript.g:
		                            if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
		                            {
		                                input.Consume();
		                            }
		                            else
		                            {
		                                MismatchedSetException mse = new MismatchedSetException(null, input);
		                                Recover(mse);
		                                throw mse;
		                            }
		                            break;
		                        }

		                        default:
		                        {
		                            goto loop4_break;
		                        }
		                    }
                                //loop4_continue: ; // LUCENENET NOTE: Not used
                        }
                        loop4_break: ;
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: ( EXPONENT )?
		                int alt5 = 2;
		                int LA5_0 = input.LA(1);
		                if ((LA5_0 == 'E' || LA5_0 == 'e'))
		                {
		                    alt5 = 1;
		                }
		                switch (alt5)
		                {
		                    case 1:
		                    {
		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: EXPONENT
		                        MEXPONENT();
		                        break;
		                    }
		                }
		                break;
		            }

		            case 2:
		            {
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:7: AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )?
		                MAT_DOT();
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:14: ( DECIMALDIGIT )+
		                int cnt6 = 0;
		                while (true)
		                {
		                    int alt6 = 2;
		                    int LA6_0 = input.LA(1);
		                    if (((LA6_0 >= '0' && LA6_0 <= '9')))
		                    {
		                        alt6 = 1;
		                    }
		                    switch (alt6)
		                    {
		                        case 1:
		                        {
		                            // src/java/org/apache/lucene/expressions/js/Javascript.g:
		                            if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
		                            {
		                                input.Consume();
		                            }
		                            else
		                            {
		                                MismatchedSetException mse = new MismatchedSetException(null, input);
		                                Recover(mse);
		                                throw mse;
		                            }
		                            break;
		                        }

		                        default:
		                        {
		                            if (cnt6 >= 1)
		                            {
		                                goto loop6_break;
		                            }
		                            EarlyExitException eee = new EarlyExitException(6, input);
		                            throw eee;
		                        }
		                    }
		                    cnt6++;
                                //loop6_continue: ; // LUCENENET NOTE: Not used
                            }
                            loop6_break: ;
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: ( EXPONENT )?
		                int alt7 = 2;
		                int LA7_0 = input.LA(1);
		                if ((LA7_0 == 'E' || LA7_0 == 'e'))
		                {
		                    alt7 = 1;
		                }
		                switch (alt7)
		                {
		                    case 1:
		                    {
		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: EXPONENT
		                        MEXPONENT();
		                        break;
		                    }
		                }
		                break;
		            }

		            case 3:
		            {
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:349:7: DECIMALINTEGER ( EXPONENT )?
		                MDECIMALINTEGER();
		                // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: ( EXPONENT )?
		                int alt8 = 2;
		                int LA8_0 = input.LA(1);
		                if ((LA8_0 == 'E' || LA8_0 == 'e'))
		                {
		                    alt8 = 1;
		                }
		                switch (alt8)
		                {
		                    case 1:
		                    {
		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: EXPONENT
		                        MEXPONENT();
		                        break;
		                    }
		                }
		                break;
		            }
		        }
		        state.type = type;
		        state.channel = channel;
		    }
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "DECIMAL"
		// $ANTLR start "OCTAL"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MOCTAL()
		{
			try
			{
				int _type = OCTAL;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:353:5: ( '0' ( OCTALDIGIT )+ )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:353:7: '0' ( OCTALDIGIT )+
					Match('0');
					// src/java/org/apache/lucene/expressions/js/Javascript.g:353:11: ( OCTALDIGIT )+
					int cnt10 = 0;
					while (true)
					{
						int alt10 = 2;
						int LA10_0 = input.LA(1);
						if (((LA10_0 >= '0' && LA10_0 <= '7')))
						{
							alt10 = 1;
						}
						switch (alt10)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:
								if ((input.LA(1) >= '0' && input.LA(1) <= '7'))
								{
									input.Consume();
								}
								else
								{
									MismatchedSetException mse = new MismatchedSetException(null, input);
									Recover(mse);
									throw mse;
								}
								break;
							}

							default:
							{
								if (cnt10 >= 1)
								{
									goto loop10_break;
								}
								EarlyExitException eee = new EarlyExitException(10, input);
								throw eee;
							}
						}
						cnt10++;
                        //loop10_continue: ; // LUCENENET NOTE: Not used
                    }
                    loop10_break: ;
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "OCTAL"
		// $ANTLR start "HEX"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MHEX()
		{
			try
			{
				int _type = HEX;
				int _channel = TokenChannels.Default;
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:357:5: ( ( '0x' | '0X' ) ( HEXDIGIT )+ )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:357:7: ( '0x' | '0X' ) ( HEXDIGIT )+
					// src/java/org/apache/lucene/expressions/js/Javascript.g:357:7: ( '0x' | '0X' )
					int alt11 = 2;
					int LA11_0 = input.LA(1);
					if ((LA11_0 == '0'))
					{
						int LA11_1 = input.LA(2);
						if ((LA11_1 == 'x'))
						{
							alt11 = 1;
						}
						else
						{
							if ((LA11_1 == 'X'))
							{
								alt11 = 2;
							}
							else
							{
								int nvaeMark = input.Mark();
								try
								{
									input.Consume();
									NoViableAltException nvae = new NoViableAltException(string.Empty, 11, 1, input);
									throw nvae;
								}
								finally
								{
									input.Rewind(nvaeMark);
								}
							}
						}
					}
					else
					{
						NoViableAltException nvae = new NoViableAltException(string.Empty, 11, 0, input);
						throw nvae;
					}
					switch (alt11)
					{
						case 1:
						{
							// src/java/org/apache/lucene/expressions/js/Javascript.g:357:8: '0x'
							Match("0x");
							break;
						}

						case 2:
						{
							// src/java/org/apache/lucene/expressions/js/Javascript.g:357:13: '0X'
							Match("0X");
							break;
						}
					}
					// src/java/org/apache/lucene/expressions/js/Javascript.g:357:19: ( HEXDIGIT )+
					int cnt12 = 0;
					while (true)
					{
						int alt12 = 2;
						int LA12_0 = input.LA(1);
						if (((LA12_0 >= '0' && LA12_0 <= '9') || (LA12_0 >= 'A' && LA12_0 <= 'F') || (LA12_0
							 >= 'a' && LA12_0 <= 'f')))
						{
							alt12 = 1;
						}
						switch (alt12)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:
								if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
									(1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f'))
								{
									input.Consume();
								}
								else
								{
									MismatchedSetException mse = new MismatchedSetException(null, input);
									Recover(mse);
									throw mse;
								}
								break;
							}

							default:
							{
								if (cnt12 >= 1)
								{
									goto loop12_break;
								}
								EarlyExitException eee = new EarlyExitException(12, input);
								throw eee;
							}
						}
						cnt12++;
                        //loop12_continue: ; // LUCENENET NOTE: Not used
                    }
                    loop12_break: ;
				}
				state.type = _type;
				state.channel = _channel;
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "HEX"
		// $ANTLR start "DECIMALINTEGER"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MDECIMALINTEGER()
		{
			try
			{
				// src/java/org/apache/lucene/expressions/js/Javascript.g:363:5: ( '0' | '1' .. '9' ( DECIMALDIGIT )* )
				int alt14 = 2;
				int LA14_0 = input.LA(1);
				if ((LA14_0 == '0'))
				{
					alt14 = 1;
				}
				else
				{
					if (((LA14_0 >= '1' && LA14_0 <= '9')))
					{
						alt14 = 2;
					}
					else
					{
						NoViableAltException nvae = new NoViableAltException(string.Empty, 14, 0, input);
						throw nvae;
					}
				}
				switch (alt14)
				{
					case 1:
					{
						// src/java/org/apache/lucene/expressions/js/Javascript.g:363:7: '0'
						Match('0');
						break;
					}

					case 2:
					{
						// src/java/org/apache/lucene/expressions/js/Javascript.g:364:7: '1' .. '9' ( DECIMALDIGIT )*
						MatchRange('1', '9');
						// src/java/org/apache/lucene/expressions/js/Javascript.g:364:16: ( DECIMALDIGIT )*
						while (true)
						{
							int alt13 = 2;
							int LA13_0 = input.LA(1);
							if (((LA13_0 >= '0' && LA13_0 <= '9')))
							{
								alt13 = 1;
							}
							switch (alt13)
							{
								case 1:
								{
									// src/java/org/apache/lucene/expressions/js/Javascript.g:
									if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
									{
										input.Consume();
									}
									else
									{
										MismatchedSetException mse = new MismatchedSetException(null, input);
										Recover(mse);
										throw mse;
									}
									break;
								}

								default:
								{
									goto loop13_break;
								}
							}
                                //loop13_continue: ; // LUCENENET NOTE: Not used
                            }
                            loop13_break: ;
						break;
					}
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "DECIMALINTEGER"
		// $ANTLR start "EXPONENT"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MEXPONENT()
		{
			try
			{
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:369:5: ( ( 'e' | 'E' ) ( '+' | '-' )? ( DECIMALDIGIT )+ )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:369:7: ( 'e' | 'E' ) ( '+' | '-' )? ( DECIMALDIGIT )+
					if (input.LA(1) == 'E' || input.LA(1) == 'e')
					{
						input.Consume();
					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null, input);
						Recover(mse);
						throw mse;
					}
					// src/java/org/apache/lucene/expressions/js/Javascript.g:369:17: ( '+' | '-' )?
					int alt15 = 2;
					int LA15_0 = input.LA(1);
					if ((LA15_0 == '+' || LA15_0 == '-'))
					{
						alt15 = 1;
					}
					switch (alt15)
					{
						case 1:
						{
							// src/java/org/apache/lucene/expressions/js/Javascript.g:
							if (input.LA(1) == '+' || input.LA(1) == '-')
							{
								input.Consume();
							}
							else
							{
								MismatchedSetException mse = new MismatchedSetException(null, input);
								Recover(mse);
								throw mse;
							}
							break;
						}
					}
					// src/java/org/apache/lucene/expressions/js/Javascript.g:369:28: ( DECIMALDIGIT )+
					int cnt16 = 0;
					while (true)
					{
						int alt16 = 2;
						int LA16_0 = input.LA(1);
						if (((LA16_0 >= '0' && LA16_0 <= '9')))
						{
							alt16 = 1;
						}
						switch (alt16)
						{
							case 1:
							{
								// src/java/org/apache/lucene/expressions/js/Javascript.g:
								if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
								{
									input.Consume();
								}
								else
								{
									MismatchedSetException mse = new MismatchedSetException(null, input);
									Recover(mse);
									throw mse;
								}
								break;
							}

							default:
							{
								if (cnt16 >= 1)
								{
									goto loop16_break;
								}
								EarlyExitException eee = new EarlyExitException(16, input);
								throw eee;
							}
						}
						cnt16++;
                        //loop16_continue: ; // LUCENENET NOTE: Not used
                    }
                    loop16_break: ;
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "EXPONENT"
		// $ANTLR start "DECIMALDIGIT"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MDECIMALDIGIT()
		{
			try
			{
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:374:5: ( '0' .. '9' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:
					if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
					{
						input.Consume();
					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null, input);
						Recover(mse);
						throw mse;
					}
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "DECIMALDIGIT"
		// $ANTLR start "HEXDIGIT"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MHEXDIGIT()
		{
			try
			{
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:379:5: ( DECIMALDIGIT | 'a' .. 'f' | 'A' .. 'F' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:
					if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
						(1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f'))
					{
						input.Consume();
					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null, input);
						Recover(mse);
						throw mse;
					}
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "HEXDIGIT"
		// $ANTLR start "OCTALDIGIT"
		/// <exception cref="Antlr.Runtime.RecognitionException"></exception>
		public void MOCTALDIGIT()
		{
			try
			{
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:386:5: ( '0' .. '7' )
					// src/java/org/apache/lucene/expressions/js/Javascript.g:
					if ((input.LA(1) >= '0' && input.LA(1) <= '7'))
					{
						input.Consume();
					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null, input);
						Recover(mse);
						throw mse;
					}
				}
			}
			finally
			{
			}
		}

		// do for sure before leaving
		// $ANTLR end "OCTALDIGIT"
		
		public override void mTokens()
		{
			// src/java/org/apache/lucene/expressions/js/Javascript.g:1:8: ( AT_ADD | AT_BIT_AND | AT_BIT_NOT | AT_BIT_OR | AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU | AT_BIT_XOR | AT_BOOL_AND | AT_BOOL_NOT | AT_BOOL_OR | AT_COLON | AT_COMMA | AT_COMP_EQ | AT_COMP_GT | AT_COMP_GTE | AT_COMP_LT | AT_COMP_LTE | AT_COMP_NEQ | AT_COND_QUE | AT_DIVIDE | AT_DOT | AT_LPAREN | AT_MODULO | AT_MULTIPLY | AT_RPAREN | AT_SUBTRACT | NAMESPACE_ID | WS | DECIMAL | OCTAL | HEX )
			int alt17 = 32;
			switch (input.LA(1))
			{
				case '+':
				{
					alt17 = 1;
					break;
				}

				case '&':
				{
					int LA17_2 = input.LA(2);
					if ((LA17_2 == '&'))
					{
						alt17 = 9;
					}
					else
					{
						alt17 = 2;
					}
					break;
				}

				case '~':
				{
					alt17 = 3;
					break;
				}

				case '|':
				{
					int LA17_4 = input.LA(2);
					if ((LA17_4 == '|'))
					{
						alt17 = 11;
					}
					else
					{
						alt17 = 4;
					}
					break;
				}

				case '<':
				{
					switch (input.LA(2))
					{
						case '<':
						{
							alt17 = 5;
							break;
						}

						case '=':
						{
							alt17 = 18;
							break;
						}

						default:
						{
							alt17 = 17;
							break;
						}
					}
					break;
				}

				case '>':
				{
					switch (input.LA(2))
					{
						case '>':
						{
							int LA17_31 = input.LA(3);
							if ((LA17_31 == '>'))
							{
								alt17 = 7;
							}
							else
							{
								alt17 = 6;
							}
							break;
						}

						case '=':
						{
							alt17 = 16;
							break;
						}

						default:
						{
							alt17 = 15;
							break;
						}
					}
					break;
				}

				case '^':
				{
					alt17 = 8;
					break;
				}

				case '!':
				{
					int LA17_8 = input.LA(2);
					if ((LA17_8 == '='))
					{
						alt17 = 19;
					}
					else
					{
						alt17 = 10;
					}
					break;
				}

				case ':':
				{
					alt17 = 12;
					break;
				}

				case ',':
				{
					alt17 = 13;
					break;
				}

				case '=':
				{
					alt17 = 14;
					break;
				}

				case '?':
				{
					alt17 = 20;
					break;
				}

				case '/':
				{
					alt17 = 21;
					break;
				}

				case '.':
				{
					int LA17_14 = input.LA(2);
					if (((LA17_14 >= '0' && LA17_14 <= '9')))
					{
						alt17 = 30;
					}
					else
					{
						alt17 = 22;
					}
					break;
				}

				case '(':
				{
					alt17 = 23;
					break;
				}

				case '%':
				{
					alt17 = 24;
					break;
				}

				case '*':
				{
					alt17 = 25;
					break;
				}

				case ')':
				{
					alt17 = 26;
					break;
				}

				case '-':
				{
					alt17 = 27;
					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 '_':
				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':
				{
					alt17 = 28;
					break;
				}

				case '\t':
				case '\n':
				case '\r':
				case ' ':
				{
					alt17 = 29;
					break;
				}

				case '0':
				{
					switch (input.LA(2))
					{
						case 'X':
						case 'x':
						{
							alt17 = 32;
							break;
						}

						case '0':
						case '1':
						case '2':
						case '3':
						case '4':
						case '5':
						case '6':
						case '7':
						{
							alt17 = 31;
							break;
						}

						default:
						{
							alt17 = 30;
							break;
						}
					}
					break;
				}

				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				{
					alt17 = 30;
					break;
				}

				default:
				{
					NoViableAltException nvae = new NoViableAltException(string.Empty, 17, 0, input);
					throw nvae;
				}
			}
			switch (alt17)
			{
				case 1:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:10: AT_ADD
					MAT_ADD();
					break;
				}

				case 2:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:17: AT_BIT_AND
					MAT_BIT_AND();
					break;
				}

				case 3:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:28: AT_BIT_NOT
					MAT_BIT_NOT();
					break;
				}

				case 4:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:39: AT_BIT_OR
					MAT_BIT_OR();
					break;
				}

				case 5:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:49: AT_BIT_SHL
					MAT_BIT_SHL();
					break;
				}

				case 6:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:60: AT_BIT_SHR
					MAT_BIT_SHR();
					break;
				}

				case 7:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:71: AT_BIT_SHU
					MAT_BIT_SHU();
					break;
				}

				case 8:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:82: AT_BIT_XOR
					MAT_BIT_XOR();
					break;
				}

				case 9:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:93: AT_BOOL_AND
					MAT_BOOL_AND();
					break;
				}

				case 10:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:105: AT_BOOL_NOT
					MAT_BOOL_NOT();
					break;
				}

				case 11:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:117: AT_BOOL_OR
					MAT_BOOL_OR();
					break;
				}

				case 12:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:128: AT_COLON
					MAT_COLON();
					break;
				}

				case 13:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:137: AT_COMMA
					MAT_COMMA();
					break;
				}

				case 14:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:146: AT_COMP_EQ
					MAT_COMP_EQ();
					break;
				}

				case 15:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:157: AT_COMP_GT
					MAT_COMP_GT();
					break;
				}

				case 16:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:168: AT_COMP_GTE
					MAT_COMP_GTE();
					break;
				}

				case 17:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:180: AT_COMP_LT
					MAT_COMP_LT();
					break;
				}

				case 18:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:191: AT_COMP_LTE
					MAT_COMP_LTE();
					break;
				}

				case 19:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:203: AT_COMP_NEQ
					MAT_COMP_NEQ();
					break;
				}

				case 20:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:215: AT_COND_QUE
					MAT_COND_QUE();
					break;
				}

				case 21:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:227: AT_DIVIDE
					MAT_DIVIDE();
					break;
				}

				case 22:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:237: AT_DOT
					MAT_DOT();
					break;
				}

				case 23:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:244: AT_LPAREN
					MAT_LPAREN();
					break;
				}

				case 24:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:254: AT_MODULO
					MAT_MODULO();
					break;
				}

				case 25:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:264: AT_MULTIPLY
					MAT_MULTIPLY();
					break;
				}

				case 26:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:276: AT_RPAREN
					MAT_RPAREN();
					break;
				}

				case 27:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:286: AT_SUBTRACT
					MAT_SUBTRACT();
					break;
				}

				case 28:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:298: NAMESPACE_ID
					MNAMESPACE_ID();
					break;
				}

				case 29:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:311: WS
					MWS();
					break;
				}

				case 30:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:314: DECIMAL
					MDECIMAL();
					break;
				}

				case 31:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:322: OCTAL
					MOCTAL();
					break;
				}

				case 32:
				{
					// src/java/org/apache/lucene/expressions/js/Javascript.g:1:328: HEX
					MHEX();
					break;
				}
			}
		}

		protected JavascriptLexer.DFA9 m_dfa9;

		internal static readonly string DFA9_eotS = "\x1\uffff\x2\x4\x3\uffff\x1\x4";

		internal static readonly string DFA9_eofS = "\x7\uffff";

		internal static readonly string DFA9_minS = "\x3\x30\x3\uffff\x1\x30";

		internal static readonly string DFA9_maxS = "\x1\x49\x1\x30\x1\x49\x3\uffff\x1\x49";

		internal static readonly string DFA9_acceptS = "\x3\uffff\x1\x2\x1\x3\x1\x1\x1\uffff";

		internal static readonly string DFA9_specialS = "\x7\uffff}>";

		internal static readonly string[] DFA9_transitionS = new string[] { "\x1\x3\x1\uffff\x1\x1\xb\x2"
			, "\x1\x5", "\x1\x5\x1\uffff\xc\x6", string.Empty, string.Empty, string.Empty, "\x1\x5\x1\uffff\xc\x6"
			 };

		internal static readonly short[] DFA9_eot = DFA.UnpackEncodedString(DFA9_eotS);

		internal static readonly short[] DFA9_eof = DFA.UnpackEncodedString(DFA9_eofS);

	    internal static readonly char[] DFA9_min = {'.','.','.','?','?','?','.'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_minS);

	    internal static readonly char[] DFA9_max = {'9', '.', '9', '?', '?', '?', '9'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_maxS);

		internal static readonly short[] DFA9_accept = DFA.UnpackEncodedString(DFA9_acceptS
			);

		internal static readonly short[] DFA9_special = DFA.UnpackEncodedString(DFA9_specialS
			);

		internal static readonly short[][] DFA9_transition = LoadDFA9Transition();

		private static short[][] LoadDFA9Transition() // LUCENENET: Avoid static constructors (see https://github.com/apache/lucenenet/pull/224#issuecomment-469284006)
        {
			int numStates = DFA9_transitionS.Length;
			var DFA9_transition = new short[numStates][];
			for (int i = 0; i < numStates; i++)
			{
				DFA9_transition[i] = DFA.UnpackEncodedString(DFA9_transitionS[i]);
			}
            return DFA9_transition;
		}

		protected class DFA9 : DFA
		{
			public DFA9(JavascriptLexer _enclosing, BaseRecognizer recognizer)
			{
				this._enclosing = _enclosing;
				this.recognizer = recognizer;
				this.decisionNumber = 9;
				this.eot = DFA9_eot;
				this.eof = DFA9_eof;
				this.min = DFA9_min;
				this.max = DFA9_max;
				this.accept = DFA9_accept;
				this.special = DFA9_special;
				this.transition = DFA9_transition;
			}

			public override string Description
			{
			    get
			    {
			        return
			            "346:1: DECIMAL : ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? );";
			    }
			}

			private readonly JavascriptLexer _enclosing;
		}
	}

    // LUCENENET: It is no longer good practice to use binary serialization. 
    // See: https://github.com/dotnet/corefx/issues/23584#issuecomment-325724568
#if FEATURE_SERIALIZABLE_EXCEPTIONS
    [Serializable]
#endif
    public class ParseException : Exception
    {
        public ParseException(string message, int charPositionInLine)
            : base(message + ": " + charPositionInLine)
        {
        }

#if FEATURE_SERIALIZABLE_EXCEPTIONS
        // For testing
        public ParseException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of this class with serialized data.
        /// </summary>
        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
        protected ParseException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
#endif
    }
}
