public static IntegerLiteralExpression ParseIntegerLiteralExpression(antlr.IToken token, string s, bool asLong)
        {
            const string HEX_PREFIX = "0x";

            NumberStyles style = NumberStyles.Integer | NumberStyles.AllowExponent;
            int hex_start = s.IndexOf(HEX_PREFIX);
            bool negative = false;

            if (hex_start >= 0)
            {
                if (s.StartsWith("-"))
                {
                    negative = true;
                }
                s = s.Substring(hex_start + HEX_PREFIX.Length);
                style = NumberStyles.HexNumber;
            }

            long value = long.Parse(s, style, CultureInfo.InvariantCulture);
            if (negative) //negative hex number
            {
                value *= -1;
            }
            return new IntegerLiteralExpression(SourceLocationFactory.ToLexicalInfo(token), value, asLong || (value > int.MaxValue || value < int.MinValue));
        }

        public void ResolveBooTokenStartAndEndIndex(antlr.CommonToken token, TokenInfo tokenInfo)
        {
            int oneCharBack = token.getColumn() - 1;
            int lengthOfTokenText = token.getText() == null ? 0 : token.getText().Length;
            int oneCharAfterToken = token.getColumn() + lengthOfTokenText;

            // single quoted string
            if (token.Type == BooLexer.SINGLE_QUOTED_STRING || token.Type == BooLexer.DOUBLE_QUOTED_STRING)
            {
                tokenInfo.StartIndex = oneCharBack;
                tokenInfo.EndIndex = oneCharAfterToken;
            }
            else if (token.Type == BooLexer.TRIPLE_QUOTED_STRING)
            {
                tokenInfo.StartIndex = oneCharBack;
                tokenInfo.EndIndex = oneCharBack+ 5 + token.getText().Length;
            }
            else if (token.Type == 1)
            {
                return;
            }
            else
            {
                tokenInfo.StartIndex = oneCharBack;
                tokenInfo.EndIndex = oneCharBack + (token.getText().Length - 1);
            }
        }

	protected LexicalInfo ToLexicalInfo(antlr.IToken token)
	{
		int line = token.getLine();
		int startColumn = token.getColumn();
		int endColumn = token.getColumn() + token.getText().Length;
		String filename = token.getFilename();
		return new LexicalInfo(filename, line, startColumn, endColumn);
	}

 void OnParserError(antlr.RecognitionException error)
 {
     var location = new LexicalInfo(error.getFilename(), error.getLine(), error.getColumn());
     var nvae = error as antlr.NoViableAltException;
     if (null != nvae)
         ParserError(location, nvae);
     else
         GenericParserError(location, error);
 }

		public static double ParseDouble(antlr.IToken token, string s, bool isSingle)
		{
			try
			{
				return TryParseDouble(isSingle, s);
			}
			catch (Exception x)
			{
				LexicalInfo sourceLocation = ToLexicalInfo(token);
				GenericParserError(sourceLocation, x);
				// let the parser continue
				return double.NaN;
			}
		}

		public static TimeSpan ParseTimeSpan(antlr.IToken token, string text)
		{
			try
			{
				return TryParseTimeSpan(token, text);
			}
			catch (System.OverflowException x)
			{
				LexicalInfo sourceLocation = ToLexicalInfo(token);
				GenericParserError(sourceLocation, x);
				// let the parser continue
				return TimeSpan.Zero;
			}
		}

		public IndentTokenStreamFilter(antlr.TokenStream istream, int wsTokenType, int indentTokenType, int dedentTokenType, int eosTokenType)
		{
			if (null == istream)
			{
				throw new ArgumentNullException("istream");
			}

			_istream = istream;
			_wsTokenType = wsTokenType;
			_indentTokenType = indentTokenType;
			_dedentTokenType = dedentTokenType;
			_eosTokenType = eosTokenType;
			_indentStack = new Stack();
			_pendingTokens = new Queue();

			_indentStack.Push(0); // current indent level is zero
		}

		private static TimeSpan TryParseTimeSpan(antlr.IToken token, string text)
		{
			if (text.EndsWith("ms"))
			{
				return TimeSpan.FromMilliseconds(
					ParseDouble(token, text.Substring(0, text.Length - 2)));
			}

			char last = text[text.Length - 1];
			double value = ParseDouble(token, text.Substring(0, text.Length - 1));
			switch (last)
			{
				case 's': return TimeSpan.FromSeconds(value);
				case 'h': return TimeSpan.FromHours(value);
				case 'm': return TimeSpan.FromMinutes(value);
				case 'd': return TimeSpan.FromDays(value);
			}
			throw new ArgumentException(text, "text");
		}

 void Enqueue(antlr.IToken token, string text)
 {
     token.setText(text);
     EnqueueInterpolatedToken(token);
 }

		override public void reportError(antlr.RecognitionException x)
		{
			if (null != Error)
				Error(x);
			else
				base.reportError(x);
		}

 public static SourceLocation ToSourceLocation(antlr.IToken token)
 {
     return new SourceLocation(token.getLine(), token.getColumn());
 }

 public static SourceLocation ToEndSourceLocation(antlr.IToken token)
 {
     return new SourceLocation(token.getLine(), token.getColumn() + token.getText().Length - 1);
 }

		public static SourceLocation ToEndSourceLocation(antlr.IToken token)
		{
			string text = token.getText() ?? "";
			return new SourceLocation(token.getLine(), token.getColumn() + text.Length - 1);
		}

 antlr.IToken CreateToken(antlr.IToken prototype, int newTokenType, string newTokenText)
 {
     return new BooToken(newTokenType, newTokenText,
         prototype.getFilename(),
         prototype.getLine(),
         prototype.getColumn()+SafeGetLength(prototype.getText()));
 }

        void CheckForEOF(antlr.IToken token)
        {
            if (antlr.Token.EOF_TYPE != token.Type) return;

            EnqueueEOS(token);
            while (CurrentIndentLevel > 0)
            {
                EnqueueDedent();
                _indentStack.Pop();
            }
        }

        public static BooTokenType GetTokenType(antlr.IToken token)
        {
            switch (token.Type)
            {
                case BooLexer.TRIPLE_QUOTED_STRING: return BooTokenType.DocumentString;

                case BooLexer.DOUBLE_QUOTED_STRING:
                case BooLexer.SINGLE_QUOTED_STRING:
                    return BooTokenType.String;

                case BooLexer.DOT: return BooTokenType.MemberSelector;

                case BooLexer.WS: return BooTokenType.WhiteSpace;

                case BooLexer.ID: return BooTokenType.Identifier;

                case BooLexer.ABSTRACT:
                case BooLexer.AS:
                case BooLexer.BREAK:
                case BooLexer.CLASS:
                case BooLexer.CONSTRUCTOR:
                case BooLexer.CONTINUE:
                case BooLexer.DEF:
                case BooLexer.DO:
                case BooLexer.ELIF:
                case BooLexer.ELSE:
                case BooLexer.ENUM:
                case BooLexer.EVENT:
                case BooLexer.EXCEPT:
                case BooLexer.FALSE:
                case BooLexer.FINAL:
                case BooLexer.FOR:
                case BooLexer.FROM:
                case BooLexer.GET:
                case BooLexer.GOTO:
                case BooLexer.IF:
                case BooLexer.IMPORT:
                case BooLexer.IN:
                case BooLexer.INTERFACE:
                case BooLexer.INTERNAL:
                case BooLexer.IS:
                case BooLexer.LONG:
                case BooLexer.NAMESPACE:
                case BooLexer.NULL:
                case BooLexer.OF:
                case BooLexer.OVERRIDE:
                case BooLexer.PARTIAL:
                case BooLexer.PASS:
                case BooLexer.PRIVATE:
                case BooLexer.PROTECTED:
                case BooLexer.PUBLIC:
                case BooLexer.RAISE:
                case BooLexer.REF:
                case BooLexer.RETURN:
                case BooLexer.SELF:
                case BooLexer.SET:
                case BooLexer.STATIC:
                case BooLexer.STRUCT:
                case BooLexer.SUPER:
                case BooLexer.THEN:
                case BooLexer.TRUE:
                case BooLexer.TRY:
                case BooLexer.TYPEOF:
                case BooLexer.UNLESS:
                case BooLexer.VIRTUAL:
                case BooLexer.WHILE:
                case BooLexer.YIELD:
                    return BooTokenType.Keyword;

                default: return BooTokenType.Other;
            }
        }

		void ParserError(LexicalInfo data, antlr.NoViableAltException error)
		{			
			_context.Errors.Add(CompilerErrorFactory.UnexpectedToken(data, error, error.token.getText()));
		}

 void Enqueue(antlr.IToken token)
 {
     _pendingTokens.Enqueue(token);
 }

 public override void reportError(antlr.RecognitionException x)
 {
     if (null != Error)
     {
         Error(x);
     }
     else
     {
         base.reportError(x);
     }
 }

 void EnqueueEOS(antlr.IToken prototype)
 {
     _pendingTokens.Enqueue(CreateToken(prototype, _eosTokenType, "<EOL>"));
 }