org.antlr.v4.runtime.Parser Java Examples

@Override
protected ParseTree parse(Parser parser, IElementType root) {
	int startRule;
	if (root instanceof IFileElementType) {
		startRule = ANTLRv4Parser.RULE_grammarSpec;
	}
	else if (root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.TOKEN_REF)
		|| root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.RULE_REF)) {
		startRule = ANTLRv4Parser.RULE_atom;
	}
	else {
		startRule = Token.INVALID_TYPE;
	}

	switch (startRule) {
	case ANTLRv4Parser.RULE_grammarSpec:
		return ((ANTLRv4Parser) parser).grammarSpec();

	case ANTLRv4Parser.RULE_atom:
		return ((ANTLRv4Parser) parser).atom();

	default:
		String ruleName = ANTLRv4Parser.ruleNames[startRule];
		throw new UnsupportedOperationException(String.format("cannot start parsing using root element %s", root));
	}
}
 

/**
 * Make sure we don't attempt to recover inline; if the parser successfully
 * recovers, it won't throw an exception.
 */
@Override
public Token recoverInline(Parser recognizer) throws RecognitionException {
    InputMismatchException e = new InputMismatchException(recognizer);

    String policies = recognizer.getInputStream().getText();
    StringTokenizer tk = new StringTokenizer(policies, ";");
    String policy = "";
    int idx = 0;
    while (tk.hasMoreElements()) {
        policy = (String) tk.nextElement();
        idx += policy.length();
        if (idx >= e.getOffendingToken().getStartIndex()) {
            break;
        }
    }

    String message = Messages.get(Messages.DEFAULT_LOCALE,
            "error_invalid_firewallconfig", new Object[] {
                    e.getOffendingToken().getText(), policy });
    throw new RuntimeException(message);
}
 

protected void reportUnwantedToken(@NotNull Parser recognizer)
{
	if (inErrorRecoveryMode(recognizer))
	{
		return;
	}

	beginErrorCondition(recognizer);

	Token t = recognizer.getCurrentToken();
	String tokenName = getTokenErrorDisplay(t);
	IntervalSet expecting = getExpectedTokens(recognizer);
	String msg = "多余输入 " + tokenName + " 期望 " + expecting.toString(recognizer.getTokenNames());
	BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR, msg);
	//		exception.token = this.getGrammarToken(t);
	exception.pushToken(this.getGrammarToken(t));
	throw exception;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void reportNoViableAlternative(@NotNull Parser recognizer, @NotNull NoViableAltException e)
{
    TokenStream tokens = recognizer.getInputStream();
    String input;
    if (tokens instanceof TokenStream)
    {
        if (e.getStartToken().getType() == Token.EOF)
            input = "<EOF>";
        else
            input = getText(tokens, e.getStartToken(), e.getOffendingToken());
    }
    else
    {
        input = "<unknown input>";
    }
    String msg = "no viable alternative at input " + escapeWSAndQuote(input);
    recognizer.notifyErrorListeners(e.getOffendingToken(), msg, e);
}
 

/** Make sure we don't attempt to recover inline; if the parser
	* successfully recovers, it won't throw an exception.
	*/
	@Override
	public Token recoverInline(Parser recognizer) throws RecognitionException
	{
		// SINGLE TOKEN DELETION
		Token matchedSymbol = singleTokenDeletion(recognizer);
		if (matchedSymbol != null)
		{
			// we have deleted the extra token.
			// now, move past ttype token as if all were ok
			recognizer.consume();
			return matchedSymbol;
		}

		// SINGLE TOKEN INSERTION
		if (singleTokenInsertion(recognizer))
		{
			return getMissingSymbol(recognizer);
		}
		
//		BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR);
//		exception.pushToken(this.getGrammarToken(recognizer.getCurrentToken()));
//		throw exception;
		throw new InputMismatchException(recognizer);
	}
 

@Override
public void recover(Parser recognizer, RecognitionException e) {
    for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent()) {
        context.exception = e;
    }

    if (PredictionMode.LL.equals(recognizer.getInterpreter().getPredictionMode())) {
        if (e instanceof NoViableAltException) {
            this.reportNoViableAlternative(recognizer, (NoViableAltException) e);
        } else if (e instanceof InputMismatchException) {
            this.reportInputMismatch(recognizer, (InputMismatchException) e);
        } else if (e instanceof FailedPredicateException) {
            this.reportFailedPredicate(recognizer, (FailedPredicateException) e);
        }
    }

    throw new ParseCancellationException(e);
}
 

public ANTLRParseTreeToPSIConverter(Language language, Parser parser, PsiBuilder builder) {
	this.language = language;
	this.builder = builder;

	this.tokenElementTypes = PSIElementTypeFactory.getTokenIElementTypes(language);
	this.ruleElementTypes = PSIElementTypeFactory.getRuleIElementTypes(language);

	for (ANTLRErrorListener listener : parser.getErrorListeners()) {
		if (listener instanceof SyntaxErrorListener) {
			syntaxErrors = ((SyntaxErrorListener)listener).getSyntaxErrors();
			for (SyntaxError error : syntaxErrors) {
				// record first error per token
				int StartIndex = error.getOffendingSymbol().getStartIndex();
				if ( !tokenToErrorMap.containsKey(StartIndex) ) {
					tokenToErrorMap.put(StartIndex, error);
				}
			}
		}
	}
}
 

@BeforeEach
void beforeEach() {
    strategy = spy(GyroErrorStrategy.INSTANCE);
    recognizer = mock(Parser.class);
    token = mock(Token.class);
    set = mock(IntervalSet.class);
}
 

private ParseASTNode twoPhaseParse() {
    SQLParser sqlParser = SQLParserFactory.newInstance(databaseTypeName, sql);
    try {
        ((Parser) sqlParser).setErrorHandler(new BailErrorStrategy());
        ((Parser) sqlParser).getInterpreter().setPredictionMode(PredictionMode.SLL);
        return (ParseASTNode) sqlParser.parse();
    } catch (final ParseCancellationException ex) {
        ((Parser) sqlParser).reset();
        ((Parser) sqlParser).setErrorHandler(new DefaultErrorStrategy());
        ((Parser) sqlParser).getInterpreter().setPredictionMode(PredictionMode.LL);
        return (ParseASTNode) sqlParser.parse();
    }
}
 

@Override
public void recover(Parser recognizer, RecognitionException e)
{

	//不会执行到此处，因为在report部分就抛出异常了
	super.recover(recognizer, e);
}
 

@Override
public void reportError(Parser recognizer, RecognitionException e)
{
	// if we've already reported an error and have not matched a token
	// yet successfully, don't report any errors.
	if (inErrorRecoveryMode(recognizer))
	{
		//			System.err.print("[SPURIOUS] ");
		return; // don't report spurious errors
	}
	beginErrorCondition(recognizer);
	if (e instanceof NoViableAltException)
	{
		reportNoViableAlternative(recognizer, (NoViableAltException) e);
	}
	else if (e instanceof InputMismatchException)
	{
		reportInputMismatch(recognizer, (InputMismatchException) e);
	}
	else if (e instanceof FailedPredicateException)
	{
		reportFailedPredicate(recognizer, (FailedPredicateException) e);
	}
	else
	{
		//			System.err.println("unknown recognition error type: " + e.getClass().getName());
		BeetlException exception = new BeetlException(BeetlException.PARSER_UNKNOW_ERROR, e.getClass().getName(), e);
		//			exception.token = this.getGrammarToken(e.getOffendingToken());
		exception.pushToken(this.getGrammarToken(e.getOffendingToken()));

		throw exception;
	}
}
 

@Override
protected void beginErrorCondition(Parser parser) {
  if (inErrorRecoveryMode(parser)) {
    return;
  }
  _parserStateAtRecovery = parser.getRuleContext().toString(Arrays.asList(parser.getRuleNames()));
  super.beginErrorCondition(parser);
}
 

/** By default ANTLR makes the start/stop -1/-1 for invalid tokens
 *  which is reasonable but here we want to highlight the
 *  current position indicating that is where we lack a token.
 *  if no input, highlight at position 0.
 */
protected Token getMissingSymbol(Parser recognizer) {
	Token missingSymbol = super.getMissingSymbol(recognizer);
	// alter the default missing symbol.
	if ( missingSymbol instanceof CommonToken) {
		int start, stop;
		Token current = recognizer.getCurrentToken();
		start = current.getStartIndex();
		stop = current.getStopIndex();
		((CommonToken) missingSymbol).setStartIndex(start);
		((CommonToken) missingSymbol).setStopIndex(stop);
	}
	return missingSymbol;
}
 

@Override
public void actionPerformed(AnActionEvent e) {
	PsiElement el = MyActionUtils.getSelectedPsiElement(e);
	if ( el==null ) return;

	final String ruleName = el.getText();

	final PsiFile psiFile = e.getData(LangDataKeys.PSI_FILE);
	if ( psiFile==null ) return;

	final Project project = e.getProject();

	Editor editor = e.getData(PlatformDataKeys.EDITOR);
	if ( editor==null ) return;
	final Document doc = editor.getDocument();

	String grammarText = psiFile.getText();
	ParsingResult results = ParsingUtils.parseANTLRGrammar(grammarText);
	Parser parser = results.parser;
	ParseTree tree = results.tree;

	// find all parser and lexer rule refs
	final List<TerminalNode> rrefNodes = RefactorUtils.getAllRuleRefNodes(parser, tree, ruleName);
	if ( rrefNodes==null ) return;

	// find rule def
	final TerminalNode ruleDefNameNode = RefactorUtils.getRuleDefNameNode(parser, tree, ruleName);
	if ( ruleDefNameNode==null ) return;

	// alter rule refs and dup rules
	WriteCommandAction setTextAction = new WriteCommandAction(project) {
		@Override
		protected void run(final Result result) throws Throwable {
			// do in a single action so undo works in one go
			dupRuleAndMakeRefsUnique(doc, ruleName, rrefNodes);
		}
	};
	setTextAction.execute();
}
 

/** Instead of recovering from pendingException {@code e}, re-throw it wrapped
 *  in a {@link ParseCancellationException} so it is not caught by the
 *  rule function catches.  Use {@link Exception#getCause()} to get the
 *  original {@link RecognitionException}.
 */
@Override
public void recover(Parser recognizer, RecognitionException e) {
	// Add a compiler error message
	String message = "Cannot parse input, near '" + e.getOffendingToken().getText() + "'";
	CompilerMessage cm = new CompilerMessage(e.getOffendingToken().getInputStream().getSourceName(), e.getOffendingToken().getLine(), -1, message, MessageType.ERROR);
	CompilerMessages.get().add(cm);

	// Add pendingException to all contexts
	for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent())
		context.exception = e;

	throw new ParseCancellationException(e);
}
 

protected void reportUnwantedToken(Parser recognizer) {
  if (!this.inErrorRecoveryMode(recognizer)) {
    this.beginErrorCondition(recognizer);
    Token t = recognizer.getCurrentToken();
    String tokenName = this.getTokenErrorDisplay(t);
    IntervalSet expecting = this.getExpectedTokens(recognizer);
    String msg =
        "extraneous input " + tokenName + " expecting "
        + expecting.toString(recognizer.getVocabulary());
    recognizer.notifyErrorListeners(t, msg, (RecognitionException) null);
  }
}
 

private ParseTreePrettyPrinter(
    ParserRuleContext ctx, BatfishCombinedParser<?, ?> combinedParser, boolean printLineNumbers) {
  Parser grammar = combinedParser.getParser();
  List<String> ruleNames = Arrays.asList(grammar.getRuleNames());
  _vocabulary = grammar.getVocabulary();
  _combinedParser = combinedParser;
  _ruleNames = ruleNames;
  _ctx = ctx;
  _ptSentences = new ParseTreeSentences();
  _printLineNumbers = printLineNumbers;
  _indent = 0;
}
 

protected void reportMissingToken(@NotNull Parser recognizer)
	{
		if (inErrorRecoveryMode(recognizer))
		{
			return;
		}

		beginErrorCondition(recognizer);

//		Token t = recognizer.getCurrentToken();
		Token t = recognizer.getTokenStream().LT(-1);
		IntervalSet expecting = getExpectedTokens(recognizer);
		String expect = expecting.toString(recognizer.getTokenNames());
		if(expects.containsKey(expect)){
			expect = expects.get(expect);
		}
		if(expect.equals("'>>'")){
			expect = "'模板的占位结束符号'";
		}
		
		
		String tokenStr = getTokenErrorDisplay(t);
		String msg = null;
		if(expect.equals("'}'")&&tokenStr.equals("'>>'")) {
			 msg = "试图在第"+t.getLine()+"行未找到 '{' 匹配的结束符号 '}'";
		}else {
			//常规情况
			 msg = "缺少输入 " + expect + " 在 " + tokenStr+" 后面";
		}
		
		

		BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR, msg);
		exception.pushToken(this.getGrammarToken(t));
		throw exception;
	}
 

@Override
protected void reportUnwantedToken(Parser recognizer) {
    if (inErrorRecoveryMode(recognizer)) {
        return;
    }

    beginErrorCondition(recognizer);
    recognizer.notifyErrorListeners(recognizer.getCurrentToken(), "Extra input", null);
}
 

/**
 * Instead of recovering from exception e, rethrow it wrapped in a generic
 * RuntimeException so it is not caught by the rule function catches.
 * Exception e is the "cause" of the RuntimeException.
 */

@Override
public void recover(Parser recognizer, RecognitionException e) {
    String message = Messages.get(Messages.DEFAULT_LOCALE,
            "error_invalid_firewallconfig", new Object[] {
                    e.getOffendingToken().getText(),
                    e.getInputStream().toString() });

    throw new RuntimeException(message);
}
 

@Override
default void reportAmbiguity(
    Parser recognizer,
    DFA dfa,
    int startIndex,
    int stopIndex,
    boolean exact,
    BitSet ambigAlts,
    ATNConfigSet configs) {
    // Ignore this always.
}
 

protected void reportInputMismatch(@NotNull Parser recognizer, @NotNull InputMismatchException e)
{
	Token t1 = recognizer.getInputStream().LT(-1);
	String msg = "缺少输入在 " + getTokenErrorDisplay(t1) + " 后面， 期望 "
			+ e.getExpectedTokens().toString(recognizer.getTokenNames());
	BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR, msg, e);
	//		exception.token = this.getGrammarToken(e.getOffendingToken());
	exception.pushToken(this.getGrammarToken(t1));

	throw exception;

}
 

@Override
default void reportAttemptingFullContext(
    Parser recognizer,
    DFA dfa,
    int startIndex,
    int stopIndex,
    BitSet conflictingAlts,
    ATNConfigSet configs) {
    // Ignore this always.
}
 

/**
 *  Make sure we don't attempt to recover inline; if the parser
 *  successfully recovers, it won't throw an exception.
 *  Again, the {@link DefaultErrorStrategy#recoverInline(Parser)} gets executed
 *  to print the wrong syntax
 */
@Override
public Token recoverInline(Parser recognizer) throws RecognitionException {
  super.recoverInline(recognizer);
  InputMismatchException e = new InputMismatchException(recognizer);
  for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent()) {
    context.exception = e;
  }
  throw new ParseCancellationException(e);
}
 

@Override
default void reportContextSensitivity(
    Parser recognizer,
    DFA dfa,
    int startIndex,
    int stopIndex,
    int prediction,
    ATNConfigSet configs) {
    // Ignore this always.
}
 

@Override
public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) {
    String input = recognizer.getInputStream().getText(new Interval(startIndex, stopIndex));
    String warning = String.format("FULL AMBIGUITY: %d-%d, exact: %b, input: %s", startIndex, stopIndex, exact, input);
    logger.debug(warning);
    errors.addWarning(warning);
}
 

@Override
		public void recover(Parser recognizer, RecognitionException e) {
			int errIndex = recognizer.getInputStream().index();
			if ( firstErrorTokenIndex == -1 ) {
				firstErrorTokenIndex = errIndex; // latch
			}
//			System.err.println("recover: error at " + errIndex);
			TokenStream input = recognizer.getInputStream();
			if ( input.index()<input.size()-1 ) { // don't consume() eof
				recognizer.consume(); // just kill this bad token and let it continue.
			}
		}
 

protected void reportFailedPredicate(@NotNull Parser recognizer, @NotNull FailedPredicateException e)
{
	String ruleName = recognizer.getRuleNames()[recognizer.getContext().getRuleIndex()];
	BeetlException exception = new BeetlParserException(BeetlException.PARSER_PREDICATE_ERROR, ruleName, e);
	//		exception.token = this.getGrammarToken(e.getOffendingToken());
	exception.pushToken(this.getGrammarToken(e.getOffendingToken()));

	throw exception;
}
 

/** Make sure we don't attempt to recover inline; if the parser
 *  successfully recovers, it won't throw an pendingException.
 */
@Override
public Token recoverInline(Parser recognizer) throws RecognitionException {
	InputMismatchException e = new InputMismatchException(recognizer);

	String message = "Cannot parse input, near '" + e.getOffendingToken().getText() + "'";
	CompilerMessage cm = new CompilerMessage(e.getOffendingToken().getInputStream().getSourceName(), e.getOffendingToken().getLine(), -1, message, MessageType.ERROR);
	CompilerMessages.get().add(cm);

	// Add pendingException to all contexts
	for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent())
		context.exception = e;

	throw new ParseCancellationException(e);
}
 

@Override
public Token recoverInline(Parser recognizer)
        throws RecognitionException {

    this.recover(recognizer, new InputMismatchException(recognizer)); // stop parsing
    return null;
}