public GrammarSyntaxMessage( int msgID,
                             Grammar grammar,
                             IToken offendingToken,
                             RecognitionException exception )
     : this(msgID, grammar, offendingToken, null, exception)
 {
 }

		/// <summary>
		/// Create tree node that holds the start and stop tokens associated
		///  with an error.
		/// </summary>
		/// <remarks>
		/// <para>If you specify your own kind of tree nodes, you will likely have to
		/// override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
		/// if no token payload but you might have to set token type for diff
		/// node type.</para>
		///
		/// <para>You don't have to subclass CommonErrorNode; you will likely need to
		/// subclass your own tree node class to avoid class cast exception.</para>
		/// </remarks>
		public virtual object ErrorNode(ITokenStream input, IToken start, IToken stop,
								RecognitionException e)
		{
			CommonErrorNode t = new CommonErrorNode(input, start, stop, e);
			//System.out.println("returning error node '"+t+"' @index="+input.index());
			return t;
		}

        IToken templateToken; // overall token pulled from group file

        #endregion Fields

        #region Constructors

        public TemplateLexerMessage(string srcName, string msg, IToken templateToken, Exception cause)
            : base(ErrorType.LEXER_ERROR, null, cause, null)
        {
            this.msg = msg;
            this.templateToken = templateToken;
            this.srcName = srcName;
        }

 public TemplateCompiletimeMessage(ErrorType error, string sourceName, IToken templateToken, IToken token, Exception cause, object arg, object arg2)
     : base(error, null, cause, arg, arg2)
 {
     this._templateToken = templateToken;
     this._token = token;
     this._sourceName = sourceName;
 }

        private readonly IToken _templateToken; // overall token pulled from group file

        #endregion Fields

        #region Constructors

        public TemplateLexerMessage(string sourceName, string message, IToken templateToken, Exception cause)
            : base(ErrorType.LEXER_ERROR, null, cause, null)
        {
            this._message = message;
            this._templateToken = templateToken;
            this._sourceName = sourceName;
        }

 public GrammarSemanticsMessage( int msgID,
                       Grammar g,
                       IToken offendingToken,
                       object arg )
     : this(msgID, g, offendingToken, arg, null)
 {
 }

 public ANTLRMessage([NotNull] ErrorType errorType, [Nullable] Exception e, IToken offendingToken, params object[] args)
 {
     this.errorType = errorType;
     this.e = e;
     this.args = args;
     this.offendingToken = offendingToken;
 }

 public virtual void ProcessNested(IToken actionToken)
 {
     ANTLRStringStream @in = new ANTLRStringStream(actionToken.Text);
     @in.Line = actionToken.Line;
     @in.CharPositionInLine = actionToken.CharPositionInLine;
     ActionSplitter splitter = new ActionSplitter(@in, this);
     // forces eval, triggers listener methods
     splitter.GetActionTokens();
 }

 public ActionSniffer(Grammar g, Rule r, Alternative alt, ActionAST node, IToken actionToken)
 {
     this.g = g;
     this.r = r;
     this.alt = alt;
     this.node = node;
     this.actionToken = actionToken;
     this.errMgr = g.tool.errMgr;
 }

        public GrammarRootAST(int type, IToken t, string text, ITokenStream tokenStream)
            : base(type, t, text)
        {
            if (tokenStream == null)
            {
                throw new ArgumentNullException(nameof(tokenStream));
            }

            this.tokenStream = tokenStream;
        }

 public GrammarSemanticsMessage(ErrorType etype,
                                string fileName,
                                IToken offendingToken,
                                params object[] args)
     : base(etype, offendingToken, args)
 {
     this.fileName = fileName;
     if (offendingToken != null)
     {
         line = offendingToken.Line;
         charPosition = offendingToken.CharPositionInLine;
     }
 }

        public virtual void TrackRef(IToken x)
        {
            IList<TerminalAST> xRefs;
            if (alt.tokenRefs.TryGetValue(x.Text, out xRefs) && xRefs != null)
            {
                alt.tokenRefsInActions.Map(x.Text, node);
            }

            IList<GrammarAST> rRefs;
            if (alt.ruleRefs.TryGetValue(x.Text, out rRefs) && rRefs != null)
            {
                alt.ruleRefsInActions.Map(x.Text, node);
            }
        }

 public GrammarSyntaxMessage(ErrorType etype,
                             string fileName,
                             IToken offendingToken,
                             RecognitionException antlrException,
                             params object[] args)
     : base(etype, antlrException, offendingToken, args)
 {
     this.fileName = fileName;
     this.offendingToken = offendingToken;
     if (offendingToken != null)
     {
         line = offendingToken.Line;
         charPosition = offendingToken.CharPositionInLine;
     }
 }

        public static IList<ActionChunk> TranslateAction(OutputModelFactory factory,
                                                        RuleFunction rf,
                                                        IToken tokenWithinAction,
                                                        ActionAST node)
        {
            string action = tokenWithinAction.Text;
            if (action != null && action.Length > 0 && action[0] == '{')
            {
                int firstCurly = action.IndexOf('{');
                int lastCurly = action.LastIndexOf('}');
                if (firstCurly >= 0 && lastCurly >= 0)
                {
                    action = action.Substring(firstCurly + 1, lastCurly - firstCurly - 1); // trim {...}
                }
            }

            return TranslateActionChunk(factory, rf, action, node);
        }

 public abstract void SetTokenBoundaries(object param1, IToken param2, IToken param3);

 /// <summary>
 /// Tell me how to create a token for use with imaginary token nodes.
 /// For example, there is probably no input symbol associated with imaginary
 /// token DECL, but you need to create it as a payload or whatever for
 /// the DECL node as in ^(DECL type ID).
 /// 
 /// This is a variant of createToken where the new token is derived from
 /// an actual real input token.  Typically this is for converting '{'
 /// tokens to BLOCK etc...  You'll see
 /// 
 ///    r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
 /// 
 /// If you care what the token payload objects' type is, you should
 /// override this method and any other createToken variant.
 /// </summary>
 public abstract IToken CreateToken(IToken fromToken);

 public abstract object Create(IToken param1);

 public virtual object BecomeRoot(IToken newRoot, object oldRoot)
 {
     return BecomeRoot(Create(newRoot), oldRoot);
 }

		protected internal virtual string SerializeToken(IToken t)
		{
			StringBuilder buf = new StringBuilder(50);
			buf.Append(t.TokenIndex); buf.Append('\t');
			buf.Append(t.Type); buf.Append('\t');
			buf.Append(t.Channel); buf.Append('\t');
			buf.Append(t.Line); buf.Append('\t');
			buf.Append(t.CharPositionInLine);
			SerializeText(buf, t.Text);
			return buf.ToString();
		}

		public override void CreateNode(object node, IToken token)
		{
			int ID = adaptor.GetUniqueID(node);
			int tokenIndex = token.TokenIndex;
			Transmit("createNode\t" + ID + "\t" + tokenIndex);
		}