Пример #1
0
 public PseudoTest(string text, Type type, bool valid, ParseErrorType error)
 {
     SelectorText = text;
     ParseType    = type;
     IsValid      = valid;
     Error        = error;
 }
Пример #2
0
 internal ParseError(ParseErrorType errorType, ParseErrorLocation location, string customText)
     : this()
 {
     ErrorType = errorType;
     Location  = location;
     Text      = customText;
 }
Пример #3
0
        private ParseErrorType HandleOperatorPrecedence(ParseContext context, IOperator currentOperator)
        {
            ParseErrorType errorType    = ParseErrorType.None;
            IOperator      lastOperator = _operators.Peek();

            if (currentOperator.Precedence < lastOperator.Precedence ||
                (currentOperator.Precedence == lastOperator.Precedence &&
                 currentOperator.Associativity == Associativity.Left))
            {
                // New operator has lower or equal precedence. We need to make a tree from
                // the topmost operator and its operand(s). Example: a*b+c. + has lower priority
                // and a and b should be on the stack along with * on the operator stack.
                // Repeat until there are no more higher precendece operators on the stack.

                // If operator cas right associativity (exponent), it needs to be processed right away.
                // Consider the expression a~b~c. If the operator ~ has left associativity, this
                // expression is interpreted as (a~b)~c. If the operator has right associativity,
                // the expression is interpreted as a~(b~c). a^b^c = a^(b^c).
                // Left -associated indexer works like x[1][2] = (x[1])[2]
                errorType = this.ProcessHigherPrecendenceOperators(context, currentOperator);
            }

            if (errorType == ParseErrorType.None)
            {
                _operators.Push(currentOperator);
            }

            return(errorType);
        }
Пример #4
0
        private ParseErrorType ProcessHigherPrecendenceOperators(ParseContext context, IOperator currentOperator)
        {
            Debug.Assert(_operators.Count > 1);
            ParseErrorType errorType   = ParseErrorType.None;
            Association    association = currentOperator.Association;

            // At least one operator above sentinel is on the stack.
            do
            {
                errorType = MakeNode(context);
                if (errorType == ParseErrorType.None)
                {
                    IOperator nextOperatorNode = _operators.Peek();

                    if (association == Association.Left && nextOperatorNode.Precedence <= currentOperator.Precedence)
                    {
                        break;
                    }

                    if (association == Association.Right && nextOperatorNode.Precedence < currentOperator.Precedence)
                    {
                        break;
                    }
                }
            } while (_operators.Count > 1 && errorType == ParseErrorType.None);

            return(errorType);
        }
Пример #5
0
        // Returns true iff the script fails to compile and the first error is of the given type.
        public bool RunCompileFailTest(string script, ParseErrorType errorType, bool verbose = false)
        {
            if (verbose)
            {
                Log("-> " + script);
            }

            List <ParseErrorInst> errors = new List <ParseErrorInst>();
            object res = _Parse(_GetScriptNameFromScript(script), script, ref errors, false, false);

            if (null != res && errors.Count == 0)
            {
                if (!verbose)
                {
                    LogError("-> " + script);
                }
                LogError("ERROR: Expected 'error' script to fail to compile.");
                return(false);
            }
            if (errors.Count > 0 && ParseErrorType.Any != errorType && errors[0].type != errorType)
            {
                if (!verbose)
                {
                    LogError("-> " + script);
                }
                LogError("ERROR: 'error' script returned error (" + errors[0].type + "), expected (" + errorType + ").");
                return(false);
            }

            return(true);
        }
Пример #6
0
        /// <summary></summary>
        /// <param name="type"></param>
        /// <param name="noThrow">Does the caller want exceptions to be thrown on errors?</param>
        /// <param name="input"></param>
        /// <param name="errorState"></param>
        /// <returns>True if no error handling was needed. Else, an exception is throw (if allowed)</returns>
        static bool ParseHandleError(ParseErrorType type, bool noThrow, string input
                                     , TextStreamReadErrorState errorState)
        {
            Exception detailsException = null;

            switch (type)
            {
            case ParseErrorType.NoInput:
                if (noThrow)
                {
                    return(false);
                }

                detailsException = new ArgumentException
                                       ("Input null or empty", nameof(input));
                break;

            case ParseErrorType.InvalidValue:
                detailsException = new ArgumentException(string.Format
                                                             (Util.InvariantCultureInfo, "Couldn't parse \"{0}\"", input), nameof(input));
                break;

            default:
                return(true);
            }

            if (noThrow == false)
            {
                errorState.ThrowReadExeception(detailsException);
            }

            errorState.LogReadExceptionWarning(detailsException);
            return(true);
        }
Пример #7
0
        private OperationType HandleOperator(ParseContext context, out ParseErrorType errorType)
        {
            bool isUnary;

            errorType = this.HandleOperator(context, null, out isUnary);
            return(isUnary ? OperationType.UnaryOperator : OperationType.BinaryOperator);
        }
Пример #8
0
 public ParseError(ParseErrorType type, int line, int index, string fileName)
 {
     Type     = type;
     Index    = index;
     Line     = line;
     FileName = fileName;
 }
Пример #9
0
 public ParseError(ParseErrorType type, Vector2Int pos, int pos1, char character)
 {
     this.type      = type;
     this.pos       = pos;
     pos1d          = pos1;
     this.character = character;
 }
Пример #10
0
        /// <summary>
        /// Create and Add Parse error to the current feed result.
        /// </summary>
        /// <param name="errorType">Type of parse error.</param>
        /// <param name="nodeInformation">Current node base information.</param>
        /// <param name="feed">Current feed result.</param>
        /// <param name="content">Current node content data. (Optonal)</param>
        /// <param name="message">Parse error message. (Optional)</param>
        protected void SetParseError(ParseErrorType errorType, NodeInformation nodeInformation, Feed feed, string?content = null, string?message = null)
        {
            //Create and Add Parse error to the current feed result
            var error = ParseError.Create(nodeInformation, ToString(), errorType, feed.CurrentParseType, content, message);

            (feed.ParseError ??= new List <ParseError>()).Add(error);
            Debug.WriteLine(error);
        }
Пример #11
0
        static ParseErrorType ParseVerifyResult(ParseErrorType result, bool parseResult)
        {
            Util.MarkUnusedVariable(ref result);

            return(parseResult
                                ? ParseErrorType.None
                                : ParseErrorType.InvalidValue);
        }
Пример #12
0
 private ParseError NewParseError(ParseErrorType error, SourceLineInstruction line, int argIndex)
 {
     return(new ParseError(
                error,
                line.LineIndex,
                line.Label.Length + 2 + line.Parameters.Take(argIndex).Sum(p => p.Length),
                line.FileName));
 }
Пример #13
0
        private OperationType HandleSquareBrackets(ParseContext context, out ParseErrorType errorType)
        {
            var indexer = new Indexer();

            indexer.Parse(context, null);

            errorType = HandleOperatorPrecedence(context, indexer);
            return(OperationType.Function);
        }
Пример #14
0
        internal void LogCompileError(ParseErrorType error, string msg)
        {
            ParseErrorInst inst = new ParseErrorInst(error, msg);

            _parseErrors.Add(inst);
            if (logCompileErrors)
            {
                LogError(inst.ToString());
            }
        }
Пример #15
0
 /// <summary>
 /// Initializes a new ParseError with error information.
 /// </summary>
 /// <param name="node">Current node information.</param>
 /// <param name="parser">Current parser.</param>
 /// <param name="errorType">Current error type.</param>
 /// <param name="parseType">Current parse type.</param>
 /// <param name="parseValue">Current parse value.</param>
 /// <param name="message">Error message.</param>
 public ParseError(NodeInformation node, string parser, ParseErrorType errorType, ParseType parseType, string?parseValue = null, string?message = null)
 {
     //Init
     Node           = node;
     Parser         = parser;
     ParseErrorType = errorType;
     ParseType      = parseType;
     ParseValue     = parseValue;
     Message        = message;
 }
Пример #16
0
        private OperationType HandleLambda(ParseContext context, out ParseErrorType errorType)
        {
            errorType = ParseErrorType.None;

            var lambda = new Lambda();

            lambda.Parse(context, null);

            _operands.Push(lambda);
            return(OperationType.Operand);
        }
Пример #17
0
        /// <summary>
        /// Creates a new instance of a parse error
        /// </summary>
        /// <param name="errorType">Error type of the parse error</param>
        /// <param name="itemName">Item name of the parse error</param>
        /// <param name="itemValue">Item value of the parse error</param>
        /// <param name="message">Optional. Message of the pare error</param>
        internal ParseError(ParseErrorType errorType, string itemName, string?itemValue, string?message = null)
        {
            if (String.IsNullOrWhiteSpace(itemName))
            {
                throw new ArgumentException(Resources.MissingRequiredParameterValueErrorMessage, nameof(itemName));
            }

            this.ErrorType = errorType;
            this.ItemName  = itemName;
            this.ItemValue = itemValue;
            this.Message   = message ?? String.Empty;
        }
Пример #18
0
 public ParseError(ParseErrorType parseErrorType, int lineNum, int columnNum, Lex.Token errorInfo)
     : base(lineNum, columnNum)
 {
     if (errorInfo is Lex.Word)
     {
         Lex.Word word = errorInfo as Lex.Word;
         ErrorInfo = word.Lexeme;
     }
     else
     {
         ErrorInfo = errorInfo.TokenInfo;
     }
     ParseErrorType = parseErrorType;
 }
Пример #19
0
 public ParseError(ParseErrorType parseErrorType, int lineNum, int columnNum, Lex.Token errorInfo)
     : base(lineNum, columnNum)
 {
     if (errorInfo is Lex.Word)
     {
         Lex.Word word = errorInfo as Lex.Word;
         ErrorInfo = word.Lexeme;
     }
     else
     {
         ErrorInfo = errorInfo.TokenInfo;
     }
     ParseErrorType = parseErrorType;
 }
Пример #20
0
 /// <summary>
 /// Adds an error at the current parse location - usually after the last
 /// child. When there are no children, the error goes before any future children.
 /// </summary>
 internal void AddParseError(ParseErrorType errorType)
 {
     if (Count > 0)
     {
         this[Count - 1].AddParseError(errorType, ParseErrorLocation.AfterItem);
     }
     else if (_parent != null)
     {
         _parent.AddParseError(errorType, ParseErrorLocation.BeforeItem);
     }
     else
     {
         Debug.Fail("Can't add this parse error anywhere");
     }
 }
Пример #21
0
        private static void AddError(IList <ParseError> errors, ParseErrorType type, string message, ErrorContext context)
        {
            // Extract line info
            var regexLine = new Regex(", line (\\d+), position \\d+\\.$");
            var matchLine = regexLine.Match(context.Error.Message);

            var errorPosInfo = new ErrorPositionInfo();

            if (matchLine.Success)
            {
                errorPosInfo.LineNumber = int.Parse(matchLine.Groups[1].Value);
            }

            errors.Add(new Parsers.ParseError(type, message, errorPosInfo));
        }
Пример #22
0
        private OperationType HandleOpenBrace(ParseContext context, out ParseErrorType errorType)
        {
            var tokens = context.Tokens;

            errorType = ParseErrorType.None;

            // Separate expression from function call. In case of
            // function call previous token is either closing indexer
            // brace or closing function brace. Identifier with brace
            // is handled up above.
            // Indentifier followed by a brace needs to be analyzed
            // so we can tell between previous expression that ended
            // with identifier and identifier that is a function name:
            //
            //      a <- 2*b
            //      (expression)
            //
            // in this case b is not a function name. Similarly,
            //
            //      a <- 2*b[1]
            //      (expression)
            //
            // is not a function call operator over b[1].

            if (_operators.Count > 1 || _operands.Count > 0)
            {
                // We are not in the beginning of the expression
                if (tokens.PreviousToken.TokenType == RTokenType.CloseBrace ||
                    tokens.PreviousToken.TokenType == RTokenType.CloseSquareBracket ||
                    tokens.PreviousToken.TokenType == RTokenType.CloseDoubleSquareBracket ||
                    tokens.PreviousToken.IsVariableKind())
                {
                    var functionCall = new FunctionCall();
                    functionCall.Parse(context, null);

                    errorType = HandleOperatorPrecedence(context, functionCall);
                    return(OperationType.Function);
                }
            }

            var group = new Group();

            group.Parse(context, null);

            _operands.Push(group);
            return(OperationType.Operand);
        }
Пример #23
0
        private ParseErrorType HandleOperator(ParseContext context, IAstNode parent, out bool isUnary)
        {
            ParseErrorType errorType = ParseErrorType.None;

            // If operands stack is empty the operator is unary.
            // If operator is preceded by another operator,
            // it is interpreted as unary.

            TokenOperator currentOperator = new TokenOperator(_operands.Count == 0);

            currentOperator.Parse(context, null);
            isUnary = currentOperator.IsUnary;

            IOperator lastOperator = _operators.Peek();

            if (isUnary && lastOperator != null && lastOperator.IsUnary)
            {
                // !!!x is treated as !(!(!x)))
                // Step back and re-parse as expression
                context.Tokens.Position -= 1;
                var exp = new Expression(inGroup: false);
                if (exp.Parse(context, null))
                {
                    _operands.Push(exp);
                    return(ParseErrorType.None);
                }
            }

            if (currentOperator.Precedence <= lastOperator.Precedence &&
                !(currentOperator.OperatorType == lastOperator.OperatorType && currentOperator.Association == Association.Right))
            {
                // New operator has lower or equal precedence. We need to make a tree from
                // the topmost operator and its operand(s). Example: a*b+c. + has lower priority
                // and a and b should be on the stack along with * on the operator stack.
                // Repeat until there are no more higher precendece operators on the stack.

                errorType = this.ProcessHigherPrecendenceOperators(context, currentOperator);
            }

            if (errorType == ParseErrorType.None)
            {
                _operators.Push(currentOperator);
            }

            return(errorType);
        }
Пример #24
0
        internal bool RemoveParseError(ParseErrorType type)
        {
            bool removed = false;

            if (_parseErrors != null)
            {
                for (int i = _parseErrors.Count - 1; i >= 0; i--)
                {
                    if (_parseErrors[i].ErrorType == type)
                    {
                        _parseErrors.RemoveAt(i);
                        removed = true;
                    }
                }
            }

            return(removed);
        }
Пример #25
0
        static bool HandleParseError(ParseErrorType errorType, bool noThrow, string s, int startIndex
                                     , Text.IHandleTextParseError handler = null)
        {
            Exception detailsException = null;

            switch (errorType)
            {
            case ParseErrorType.NoInput:
                if (noThrow)
                {
                    return(false);
                }

                detailsException = new ArgumentException
                                       ("Input null or empty", nameof(s));
                break;

            case ParseErrorType.InvalidValue:
                detailsException = new ArgumentException(string.Format
                                                             (Util.InvariantCultureInfo, "Couldn't parse '{0}'", s), nameof(s));
                break;

            case ParseErrorType.InvalidStartIndex:
                detailsException = new ArgumentOutOfRangeException(nameof(s), string.Format
                                                                       (Util.InvariantCultureInfo, "'{0}' is out of range of the input length of '{1}'", startIndex, s.Length));
                break;

            default:
                return(true);
            }

            if (handler == null)
            {
                handler = Text.Util.DefaultTextParseErrorHandler;
            }

            if (noThrow == false)
            {
                handler.ThrowReadExeception(detailsException);
            }

            handler.LogReadExceptionWarning(detailsException);
            return(true);
        }
Пример #26
0
        private OperationType HandleKeyword(ParseContext context, out ParseErrorType errorType)
        {
            errorType = ParseErrorType.None;

            var keyword = context.TextProvider.GetText(context.Tokens.CurrentToken);

            if (IsTerminatingKeyword(keyword))
            {
                return(OperationType.EndOfExpression);
            }

            errorType = HandleKeyword(context, keyword);
            if (errorType == ParseErrorType.None)
            {
                return(OperationType.Operand);
            }

            return(_previousOperationType);
        }
Пример #27
0
        private ParseErrorType ProcessHigherPrecendenceOperators(ParseContext context, IOperator currentOperator)
        {
            Debug.Assert(_operators.Count > 1);
            ParseErrorType errorType        = ParseErrorType.None;
            Associativity  associativity    = currentOperator.Associativity;
            IOperator      nextOperatorNode = _operators.Peek();

            // At least one operator above sentinel is on the stack.
            do
            {
                // If associativity is right, we stop if the next operator
                // on the stack has lower or equal precedence than the current one.
                // Example: in 'a^b^c' before pushing last ^ on the stack
                // only b^c is processed since a^b^c = a^(b^c).
                if (associativity == Associativity.Right &&
                    nextOperatorNode.Precedence <= currentOperator.Precedence)
                {
                    break;
                }

                errorType = MakeNode(context);
                if (errorType == ParseErrorType.None)
                {
                    nextOperatorNode = _operators.Peek();

                    // If associativity is left, we stop if the next operator
                    // on the stack has lower precedence than the current one.
                    // Example: in 'a+b*c*d+e' before pushing last + on the stack
                    // we need to make subtree out of b*c*d.
                    if (associativity == Associativity.Left &&
                        nextOperatorNode.Precedence < currentOperator.Precedence)
                    {
                        break;
                    }
                }
            } while (_operators.Count > 1 && errorType == ParseErrorType.None);

            return(errorType);
        }
Пример #28
0
        internal bool AddParseError(ParseErrorType type, ParseErrorLocation location, string customText)
        {
            if (_parseErrors == null)
            {
                _parseErrors = new List <ParseError>();
            }
            else
            {
                // Check if it was already added

                for (int i = 0; i < _parseErrors.Count; i++)
                {
                    if (_parseErrors[i].ErrorType == type && _parseErrors[i].Location == location)
                    {
                        return(false);
                    }
                }
            }

            _parseErrors.Add(new ParseError(type, location, customText));

            return(true);
        }
Пример #29
0
        private ParseErrorType HandleKeyword(ParseContext context, string keyword)
        {
            ParseErrorType errorType = ParseErrorType.None;

            if (keyword.Equals("function", StringComparison.Ordinal))
            {
                // Special case 'exp <- function(...) { }
                FunctionDefinition funcDef = new FunctionDefinition();
                funcDef.Parse(context, null);

                // Add to the stack even if it has errors in order
                // to avoid extra errors
                _operands.Push(funcDef);
            }
            else if (keyword.Equals("if", StringComparison.Ordinal))
            {
                // If needs to know parent expression since
                // it must figure out how to handle 'else'
                // when if is without { }.
                context.Expressions.Push(this);

                InlineIf inlineIf = new InlineIf();
                inlineIf.Parse(context, null);

                context.Expressions.Pop();

                // Add to the stack even if it has errors in order
                // to avoid extra errors
                _operands.Push(inlineIf);
            }
            else
            {
                errorType = ParseErrorType.UnexpectedToken;
            }

            return(errorType);
        }
Пример #30
0
 public ParseError(ParseErrorType type, string message, ErrorPositionInfo position)
 {
     Type     = type;
     Message  = message;
     Position = position;
 }
Пример #31
0
 private OperationType HandleOperator(ParseContext context, out ParseErrorType errorType) {
     bool isUnary;
     errorType = this.HandleOperator(context, null, out isUnary);
     return isUnary ? OperationType.UnaryOperator : OperationType.BinaryOperator;
 }
Пример #32
0
        private OperationType HandleOpenBrace(ParseContext context, out ParseErrorType errorType) {
            TokenStream<RToken> tokens = context.Tokens;
            errorType = ParseErrorType.None;

            // Separate expression from function call. In case of 
            // function call previous token is either closing indexer 
            // brace or closing function brace. Identifier with brace 
            // is handled up above. 
            // Indentifier followed by a brace needs to be analyzed
            // so we can tell between previous expression that ended
            // with identifier and identifier that is a function name:
            //
            //      a <- 2*b
            //      (expression)
            //
            // in this case b is not a function name. Similarly,
            //
            //      a <- 2*b[1]
            //      (expression)
            //
            // is not a function call operator over b[1].

            if (_operators.Count > 1 || _operands.Count > 0) {
                // We are not in the beginning of the expression
                if (tokens.PreviousToken.TokenType == RTokenType.CloseBrace ||
                    tokens.PreviousToken.TokenType == RTokenType.CloseSquareBracket ||
                    tokens.PreviousToken.TokenType == RTokenType.CloseDoubleSquareBracket ||
                    tokens.PreviousToken.IsVariableKind()) {
                    FunctionCall functionCall = new FunctionCall();
                    functionCall.Parse(context, null);

                    errorType = HandleFunctionOrIndexer(functionCall);
                    return OperationType.Function;
                }
            }

            Group group = new Group();
            group.Parse(context, null);

            _operands.Push(group);
            return OperationType.Operand;
        }
Пример #33
0
 private void ErrorRecord(ParseErrorType parseErrorType)
 {
     ErrorBase.ErrorManager.AddParseError(new ParseError(parseErrorType, currentToken.LineNumber , currentToken.ColumnNumber, currentToken));
 }
 public override void SyntaxError(Antlr4.Runtime.IRecognizer recognizer, Antlr4.Runtime.IToken offendingSymbol, int line, int charPositionInLine, string msg, Antlr4.Runtime.RecognitionException e)
 {
     errorType = ParseErrorType.SyntaxError;
 }
Пример #35
0
        private OperationType HandleLambda(ParseContext context, out ParseErrorType errorType) {
            errorType = ParseErrorType.None;

            Lambda lambda = new Lambda();
            lambda.Parse(context, null);

            _operands.Push(lambda);
            return OperationType.Operand;
        }
Пример #36
0
        public static string GetText(ParseErrorType errorType)
        {
            switch (errorType)
            {
                default:
                    return Resources.ParseError_General;

                case ParseErrorType.UnexpectedToken:
                    return Resources.ParseError_UnexpectedToken;

                case ParseErrorType.IndentifierExpected:
                    return Resources.ParseError_IndentifierExpected;

                case ParseErrorType.NumberExpected:
                    return Resources.ParseError_NumberExpected;

                case ParseErrorType.LogicalExpected:
                    return Resources.ParseError_LogicalExpected;

                case ParseErrorType.StringExpected:
                    return Resources.ParseError_StringExpected;

                case ParseErrorType.ExpressionExpected:
                    return Resources.ParseError_ExpressionExpected;

                case ParseErrorType.LeftOperandExpected:
                    return Resources.ParseError_LeftOperandExpected;

                case ParseErrorType.RightOperandExpected:
                    return Resources.ParseError_RightOperandExpected;

                case ParseErrorType.OpenCurlyBraceExpected:
                    return Resources.ParseError_OpenCurlyBraceExpected;

                case ParseErrorType.CloseCurlyBraceExpected:
                    return Resources.ParseError_CloseCurlyBraceExpected;

                case ParseErrorType.OpenBraceExpected:
                    return Resources.ParseError_OpenBraceExpected;

                case ParseErrorType.CloseBraceExpected:
                    return Resources.ParseError_CloseBraceExpected;

                case ParseErrorType.OpenSquareBracketExpected:
                    return Resources.ParseError_OpenSquareBracketExpected;

                case ParseErrorType.CloseSquareBracketExpected:
                    return Resources.ParseError_CloseSquareBracketExpected;

                case ParseErrorType.OperatorExpected:
                    return Resources.ParseError_OperatorExpected;

                case ParseErrorType.FunctionExpected:
                    return Resources.ParseError_FunctionExpected;

                case ParseErrorType.InKeywordExpected:
                    return Resources.ParseError_InKeywordExpected;

                case ParseErrorType.UnexpectedEndOfFile:
                    return Resources.ParseError_UnexpectedEndOfFile;

                case ParseErrorType.FunctionBodyExpected:
                    return Resources.ParseError_FunctionBodyExpected;
            }
        }
Пример #37
0
        private OperationType HandleSquareBrackets(ParseContext context, out ParseErrorType errorType) {
            Indexer indexer = new Indexer();
            indexer.Parse(context, null);

            errorType = HandleFunctionOrIndexer(indexer);
            return OperationType.Function;
        }
Пример #38
0
 public ParseError(ParseErrorType errorType, ErrorLocation location, ITextRange range) :
     base(range) {
     this.ErrorType = errorType;
     this.Location = location;
 }
Пример #39
0
        private OperationType HandleKeyword(ParseContext context, out ParseErrorType errorType) {
            errorType = ParseErrorType.None;

            string keyword = context.TextProvider.GetText(context.Tokens.CurrentToken);
            if (IsTerminatingKeyword(keyword)) {
                return OperationType.EndOfExpression;
            }

            errorType = HandleKeyword(context, keyword);
            if (errorType == ParseErrorType.None) {
                return OperationType.Operand;
            }

            return _previousOperationType;
        }
 public MissingItemParseError(ParseErrorType errorType, RToken token) :
     base(errorType, ErrorLocation.AfterToken, token) {
 }
Пример #41
0
 public MissingItemParseError(ParseErrorType errorType, RToken token) :
     base(errorType, ErrorLocation.AfterToken, token)
 {
 }
 public override void ReportAmbiguity(Antlr4.Runtime.Parser recognizer, Antlr4.Runtime.Dfa.DFA dfa, int startIndex, int stopIndex, bool exact, Antlr4.Runtime.Sharpen.BitSet ambigAlts, Antlr4.Runtime.Atn.ATNConfigSet configs)
 {
     errorType = ParseErrorType.ReportAmbiguity;
 }