/** * Delegates visit terminal event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param node terminal node; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void visitTerminal(TerminalNode node, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { listener.visitTerminal(node); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
/** * Delegates enter rule event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param ctx enter rule context; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void delegateEnterRule(ParserRuleContext ctx, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { listener.enterEveryRule(ctx); ctx.enterRule(listener); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
/** * Delegates exit rule event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param ctx exit rule context; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void delegateExitRule(ParserRuleContext ctx, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { ctx.exitRule(listener); listener.exitEveryRule(ctx); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { listener.visitErrorNode((ErrorNode)t); return; } else if ( t instanceof TerminalNode) { listener.visitTerminal((TerminalNode)t); return; } RuleNode r = (RuleNode)t; enterRule(listener, r); int n = r.getChildCount(); for (int i = 0; i<n; i++) { walk(listener, r.getChild(i)); } exitRule(listener, r); }
/** * Delegates visit error node event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param node error node; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void visitErrorNode(ErrorNode node, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { listener.visitErrorNode(node); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
listener.visitErrorNode((ErrorNode) currentNode); listener.visitTerminal((TerminalNode) currentNode);
/** * Delegates visit error node event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param node error node; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void visitErrorNode(ErrorNode node, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { listener.visitErrorNode(node); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
if (_parseListeners != null) { for (ParseTreeListener listener : _parseListeners) { listener.visitErrorNode(node); if (_parseListeners != null) { for (ParseTreeListener listener : _parseListeners) { listener.visitTerminal(node);
/** * Notify any parse listeners of an exit rule event. * * @see #addParseListener */ protected void triggerExitRuleEvent() { // reverse order walk of listeners for (int i = _parseListeners.size()-1; i >= 0; i--) { ParseTreeListener listener = _parseListeners.get(i); _ctx.exitRule(listener); listener.exitEveryRule(_ctx); } }
/** * Notify any parse listeners of an enter rule event. * * @see #addParseListener */ protected void triggerEnterRuleEvent() { for (ParseTreeListener listener : _parseListeners) { listener.enterEveryRule(_ctx); _ctx.enterRule(listener); } }
/** * Delegates visit terminal event to collection of parsing listeners and captures parsing exceptions that may appear. * * @param node terminal node; may not be null * @param listeners collection of listeners; may not be null * @param errors collection of errors; may not be null */ public static void visitTerminal(TerminalNode node, Collection<ParseTreeListener> listeners, Collection<ParsingException> errors) { for (ParseTreeListener listener : listeners) { try { listener.visitTerminal(node); } catch (ParsingException parsingException) { AntlrDdlParser.accumulateParsingFailure(parsingException, errors); } } }
public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { listener.visitErrorNode((ErrorNode)t); return; } else if ( t instanceof TerminalNode) { listener.visitTerminal((TerminalNode)t); return; } RuleNode r = (RuleNode)t; enterRule(listener, r); int n = r.getChildCount(); for (int i = 0; i<n; i++) { walk(listener, r.getChild(i)); } exitRule(listener, r); }
protected void exitRule(ParseTreeListener listener, RuleNode r) { ParserRuleContext ctx = (ParserRuleContext)r.getRuleContext(); ctx.exitRule(listener); listener.exitEveryRule(ctx); } }
/** * The discovery of a rule node, involves sending two events: the generic * {@link ParseTreeListener#enterEveryRule} and a * {@link RuleContext}-specific event. First we trigger the generic and then * the rule specific. We to them in reverse order upon finishing the node. */ protected void enterRule(ParseTreeListener listener, RuleNode r) { ParserRuleContext ctx = (ParserRuleContext)r.getRuleContext(); listener.enterEveryRule(ctx); ctx.enterRule(listener); }
@Override public Token consume() { Token o = getCurrentToken(); if (o.getType() != EOF) { getInputStream().consume(); } boolean hasListener = _parseListeners != null && !_parseListeners.isEmpty(); if ((_buildParseTrees || hasListener) && !_errHandler.inErrorRecoveryMode(this)) { TerminalNode node = _ctx.addChild(createTerminalNode(_ctx, o)); if (_parseListeners != null) { for (ParseTreeListener listener : _parseListeners) { listener.visitTerminal(node); } } } return o; }
public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { listener.visitErrorNode((ErrorNode)t); return; } else if ( t instanceof TerminalNode) { listener.visitTerminal((TerminalNode)t); return; } RuleNode r = (RuleNode)t; enterRule(listener, r); int n = r.getChildCount(); for (int i = 0; i<n; i++) { walk(listener, r.getChild(i)); } exitRule(listener, r); }
/** * Notify any parse listeners of an exit rule event. * * @see #addParseListener */ protected void triggerExitRuleEvent() { // reverse order walk of listeners for (int i = _parseListeners.size()-1; i >= 0; i--) { ParseTreeListener listener = _parseListeners.get(i); _ctx.exitRule(listener); listener.exitEveryRule(_ctx); } }
/** * Notify any parse listeners of an enter rule event. * * @see #addParseListener */ protected void triggerEnterRuleEvent() { for (ParseTreeListener listener : _parseListeners) { listener.enterEveryRule(_ctx); _ctx.enterRule(listener); } }
public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { listener.visitErrorNode((ErrorNode)t); return; } else if ( t instanceof TerminalNode) { listener.visitTerminal((TerminalNode)t); return; } RuleNode r = (RuleNode)t; enterRule(listener, r); int n = r.getChildCount(); for (int i = 0; i<n; i++) { walk(listener, r.getChild(i)); } exitRule(listener, r); }
/** * Notify any parse listeners of an exit rule event. * * @see #addParseListener */ protected void triggerExitRuleEvent() { // reverse order walk of listeners for (int i = _parseListeners.size()-1; i >= 0; i--) { ParseTreeListener listener = _parseListeners.get(i); _ctx.exitRule(listener); listener.exitEveryRule(_ctx); } }