public override string GetErrorMessage(RecognitionException e, string[] tokenNames)
        {
            System.Collections.IList stack = GetRuleInvocationStack(e, typeof(BlaiseParser).FullName);

            string msg = string.Empty;
            if (e is NoViableAltException)
            {
                NoViableAltException nvae = (NoViableAltException)e;
                msg = "noviablealt;token=" + e.Token.ToString() +
                    "(decision=" + nvae.decisionNumber +
                    "state" + nvae.stateNumber + ")" +
                    "decision=<<" + nvae.grammarDecisionDescription + ">>";
            }
            else
            {
                msg = base.GetErrorMessage(e, tokenNames);
            }

            string stackStr = string.Empty;
            foreach (object obj in stack)
            {
                stackStr += obj.ToString();
            }

            return stackStr + " " + msg;
        }

        public override void DisplayRecognitionError(string[] tokenNames, RecognitionException e)
        {
            var outputWindow = OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense);
            if (outputWindow != null)
            {
                string header = GetErrorHeader(e);
                string message = GetErrorMessage(e, tokenNames);
                Span span = new Span();
                if (e.Token != null)
                    span = Span.FromBounds(e.Token.StartIndex, e.Token.StopIndex + 1);

                if (message.Length > 100)
                    message = message.Substring(0, 100) + " ...";

                ITextDocument document;
                if (TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document) && document != null)
                {
                    string fileName = document.FilePath;
                    var line = Snapshot.GetLineFromPosition(span.Start);
                    message = string.Format("{0}({1},{2}): {3}: {4}", fileName, line.LineNumber + 1, span.Start - line.Start.Position + 1, GetType().Name, message);
                }

                outputWindow.WriteLine(message);
            }

            base.DisplayRecognitionError(tokenNames, e);
        }

 public override string GetErrorMessage(RecognitionException e, string[] tokenNames)
 {
     if (e is MismatchedTokenException)
     {
         MismatchedTokenException exception = (MismatchedTokenException) e;
         return ("mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting " + this.GetCharErrorDisplay(exception.Expecting));
     }
     if (e is NoViableAltException)
     {
         NoViableAltException exception1 = (NoViableAltException) e;
         return ("no viable alternative at character " + this.GetCharErrorDisplay(e.Character));
     }
     if (e is EarlyExitException)
     {
         EarlyExitException exception5 = (EarlyExitException) e;
         return ("required (...)+ loop did not match anything at character " + this.GetCharErrorDisplay(e.Character));
     }
     if (e is MismatchedNotSetException)
     {
         MismatchedNotSetException exception2 = (MismatchedNotSetException) e;
         return string.Concat(new object[] { "mismatched character ", this.GetCharErrorDisplay(e.Character), " expecting set ", exception2.Expecting });
     }
     if (e is MismatchedSetException)
     {
         MismatchedSetException exception3 = (MismatchedSetException) e;
         return string.Concat(new object[] { "mismatched character ", this.GetCharErrorDisplay(e.Character), " expecting set ", exception3.Expecting });
     }
     if (e is MismatchedRangeException)
     {
         MismatchedRangeException exception4 = (MismatchedRangeException) e;
         return ("mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting set " + this.GetCharErrorDisplay(exception4.A) + ".." + this.GetCharErrorDisplay(exception4.B));
     }
     return base.GetErrorMessage(e, tokenNames);
 }

		public static QuerySyntaxException Convert(RecognitionException e, string hql)
		{
			string positionInfo = e.Line > 0 && e.CharPositionInLine > 0
			                      	? " near line " + e.Line + ", column " + e.CharPositionInLine
			                      	: "";
			return new QuerySyntaxException(e.Message + positionInfo, hql);
		}

		public void ReportError(RecognitionException e)
		{
			ReportError( e.ToString() );
			_recognitionExceptions.Add( e );
			if ( log.IsDebugEnabled ) {
				log.Debug( e.ToString(), e );
			}
		}

 public AutomationErrorNode(ITokenStream input, IToken start, IToken stop, RecognitionException ex)
 {
     var handler = new CommonErrorNode(input, start, stop, ex);
     this.isNil = handler.IsNil;
     this.type = handler.Type;
     this.text = handler.Text;
     this.toString = handler.ToString();
 }

 protected virtual void DebugRecognitionException(RecognitionException ex)
 {
     IDebugEventListener debugListener = this.recognizer.DebugListener;
     if (debugListener != null)
     {
         debugListener.RecognitionException(ex);
     }
 }

 public override void ReportError(RecognitionException e)
 {
     if ( state.errorRecovery ) {
         return;
     }
     state.syntaxErrors++; // don't count spurious
     state.errorRecovery = true;
     throw e;
 }

 /**
  * Constructor.
  *
  * @param pInput  Will be passed to the constructor of the wrapped object.
  * @param pStart  Will be passed to the constructor of the wrapped object.
  * @param pStop  Will be passed to the constructor of the wrapped object.
  * @param pException  Will be passed to the constructor of the wrapped
  *                    object.
  *
  * __TEST__
  */
 public AST2JSOMCommonErrorNode(
     ITokenStream pInput, IToken pStart, IToken pStop, 
     RecognitionException pException)
     : base()
 {
     //base();
     mCommonErrorNode =
     new CommonErrorNode(pInput, pStart, pStop, pException);
 }

        public override void DisplayRecognitionError(string[] tokenNames, RecognitionException e)
        {
            string headerError = GetErrorHeader(e);
            string error = GetErrorMessage(e, tokenNames);

            Errors.Add(new ParseException(new LineInfo(e.Line, e.CharPositionInLine), error));

            base.DisplayRecognitionError(tokenNames, e);
        }

 private static string FormatRecognitionException(RecognitionException e, string source)
 {
     var res = "Message: " + e.Message + "\n";
     res += "Token: " + e.Token.Text + "\n";
     res += "Source: " + source + "\n";
     res += "Line: " + e.Line + "\n";
     res += "Char position in line: " + e.CharPositionInLine + "\n";
     return res;
 }

        public override void DisplayRecognitionError(string[] tokenNames, RecognitionException e)
        {
            var handler = Error;
              if (handler != null)
              {
            handler(string.Format("{0} {1}", GetErrorHeader(e), GetErrorMessage(e, tokenNames)));
              }

              base.DisplayRecognitionError(tokenNames, e);
        }

        public SyntaxErrorException(string input, String antlrMessage, RecognitionException exception)
            : base(JSToCSharpExceptionType.SyntaxError, exception)
        {
            AntlrMessage = antlrMessage;
            Input = input;

            var span = AntlrException.Token == null ? -1 : AntlrException.Token.Text.Length;
            var prettyInput = input.InjectErrorMarker(LineNumber, CharPositionInLine, span).InjectLineNumbers1();
            SourceCode = prettyInput;
        }

        public static SyntaxErrorException Report(BaseRecognizer source, RecognitionException e)
        {
            var input = source.Input.ToString();
            if (source.Input is ANTLRStringStream)
                input = new String((Char[])typeof(ANTLRStringStream).GetField("data", 
                    BindingFlags.NonPublic | BindingFlags.Instance).GetValue(source.Input));

            var antlrMessage = source.GetErrorHeader(e) + " " + source.GetErrorMessage(e, source.TokenNames);
            throw new SyntaxErrorException(input, antlrMessage, e);
        }

		/// <summary>
		/// Logs the given error to the <see cref="ErrorTracker"/>.
		/// </summary>
		/// <param name="tokenNames">The names of the tokens in the current language.</param>
		/// <param name="e">The error.</param>
		public override void DisplayRecognitionError(String[] tokenNames, RecognitionException e)
		{
			LanguageError lerError = new LanguageError();
			lerError.Line = e.Line - 1;
			lerError.Column = e.CharPositionInLine;
			lerError.Position = e.Token.StartIndex;
			lerError.End = e.Token.StopIndex;
			lerError.Message = GetErrorMessage(e, tokenNames);
			ErrorTracker.ParserErrors.Add(lerError);
		}

 public CommonErrorNode(ITokenStream input, IToken start, IToken stop, RecognitionException e)
 {
     if ((stop == null) || ((stop.TokenIndex < start.TokenIndex) && (stop.Type != -1)))
     {
         stop = start;
     }
     this.input = input;
     this.start = start;
     this.stop = stop;
     this.trappedException = e;
 }

        public override void DisplayRecognitionError(String[] tokenNames, RecognitionException e)
        {
            base.DisplayRecognitionError(tokenNames, e);

            if (Errors == null)
                Errors = new List<string>();

            var hdr = GetErrorHeader(e);
            var msg = GetErrorMessage(e, tokenNames);
            Errors.Add(msg + " at " + hdr);
        }

 public override void ReportError(RecognitionException e)
 {
     if (e is MissingTokenException)
     {
         errors.Add(string.Format("{0}:{1} - Unexpected {2}\n  {3}", e.Line, e.CharPositionInLine, e.Token.Text, e));
     }
     else
     {
         errors.Add(string.Format("{0}:{1} - Error with token {2}\n  {3}", e.Line, e.CharPositionInLine, e.Token.Text, e.ToString()));
     }
     base.ReportError(e);
 }

 public override void ReportError( RecognitionException e )
 {
     StringTemplateGroup group = self.Group;
     if ( group == StringTemplate.defaultGroup )
     {
         self.Error( "action parse error; template context is " + self.GetEnclosingInstanceStackString(), e );
     }
     else
     {
         self.Error( "action parse error in group " + self.Group.Name + " line " + self.GroupFileLine + "; template context is " + self.GetEnclosingInstanceStackString(), e );
     }
 }

        /// <summary>
        /// Creates a <see cref="CompilerError"/> instance with a specific <see cref="Exception"/>.
        /// </summary>
        /// <param name="exception">Compiler exception.</param>
        public CompilerError(RecognitionException exception)
        {
            Token = exception.Token;
            var result = new StringBuilder();
            if (!string.IsNullOrEmpty(FileName))
            {
                result.AppendFormat("{0} ({1},{2}) : ", FileName, Token.Line, Token.CharPositionInLine + 1);
            }

            result.AppendFormat("error S0001 : invalid token {0}", Token.Text);
            Details = result.ToString();
        }