protected List<MatcherTransition> findTransitionsToToken(MatcherState from, Set<MatcherState> targets, boolean returning, boolean canReturn, Set<MatcherState> visited) { if (!visited.add(from)) return Collections.emptyList(); if (targets != null && targets.contains(from)) targets = null; List<MatcherTransition> result = Lists.newArrayList(); for (MatcherTransition transition : returning ? from.getOutgoingAfterReturn() : from.getOutgoing()) { if (transition.getTarget().isParserRuleCall()) result.addAll(findTransitionsToToken(transition.getTarget(), targets, false, transition.getTarget() .isParserRuleCallOptional(), visited)); else if (targets == null || targets.contains(transition.getTarget())) result.add(transition); } if (canReturn && from.isEndState()) for (MatcherState caller : findRuleCallsTo(GrammarUtil.containingRule(from.getGrammarElement()), Sets.<AbstractRule> newHashSet())) result.addAll(findTransitionsToToken(caller, targets, true, true, visited)); return result; }
protected void installBetween(IBetweenElements pattern, AbstractElement loopCenter) { Set<MatcherState> states = getAllStates(loopCenter); for (MatcherState state : states) { state.getBeforeBetweenElements().add(pattern); state.getAfterBetweenElements().add(pattern); for (MatcherTransition transition : state.getAllOutgoing()) if (transition.getLoopCenter() == loopCenter && states.contains(transition.getTarget())) transition.addPattern(pattern); } }
public Collection<T> matchNext(AbstractElement nextElement) { Pair<List<MatcherTransition>, List<MatcherState>> path = findTransitionPath(lastState, nextElement, false, true, Sets.<Pair<Boolean, MatcherState>> newHashSet()); if (path == null) { MatcherState previousState = lastState; lastState = nfaProvider.getNFA(nextElement); // System.out.println("Not Found! looking for " + new GrammarElementTitleSwitch().doSwitch(nextElement)); return patternsForTwoStates(previousState, lastState); } else { // System.out.println("Found " + path + " -> " + patternsForTransition(path)); lastState = path.getFirst().get(path.getFirst().size() - 1).getTarget(); return patternsForTransition(path); } }
transitions = returning ? from.getOutgoingAfterReturn() : from.getOutgoing(); for (MatcherTransition transition : transitions) { if (transition.getTarget().getGrammarElement() == to) return Tuples.create(Collections.singletonList(transition), Collections.singletonList(from)); else if (transition.getTarget().isParserRuleCall()) { ruleCallStack.push(transition.getTarget()); Pair<List<MatcherTransition>, List<MatcherState>> next = findTransitionPath( transition.getTarget(), to, false, transition.getTarget().isParserRuleCallOptional(), visited); if (next != null) {
protected Edge drawFollowerEdge(AbstractElement grammarElement, MatcherTransition transition, boolean isParent) { Edge edge = new Edge(grammarElement, transition.getTarget().getGrammarElement()); // if (transition.getPrecedence() > -1) // edge.setLabel(String.valueOf(transition.getPrecedence())); List<String> label = Lists.newArrayList(); if (!transition.getCommonPatterns().isEmpty()) label.add("{" + toStr(transition.getCommonPatterns()) + "}"); // for (Map.Entry<AbstractRule, Set<IElementPattern>> e : transition.getExitPatterns().entrySet()) // label.add(e.getKey().getName() + ":{" + Joiner.on(", ").join(e.getValue()).replace("\\n", "\\\\n") + "}"); for (Map.Entry<MatcherState, Set<IElementPattern>> e : transition.getGuardPatterns().entrySet()) label.add(GrammarUtil.containingRule(e.getKey().getGrammarElement()).getName() + "-" + e.getKey() + ":{" + toStr(e.getValue()) + "}"); if (label.size() > 0) edge.setLabel(Joiner.on("\\n").join(label)); if (isParent) edge.put("arrowtail", "odot"); if (transition.isRuleCall()) edge.put("arrowhead", "onormalonormal"); else edge.put("arrowhead", "onormal"); return edge; }
protected void installAfter(IAfterElement pattern) { Set<MatcherState> states = getAllStates(pattern.matchAfter()); AbstractRule rule = GrammarUtil.containingRule(pattern.matchAfter()); for (MatcherState state : states) { state.getAfterPatterns().add(pattern); for (MatcherTransition out : state.isParserRuleCall() ? state.getOutgoingAfterReturn() : state .getOutgoing()) if (pattern.matchAfter() == out.getLoopCenter() || !states.contains(out.getTarget())) out.addPattern(pattern); if (state.isEndState()) for (MatcherState caller : findRuleCallsTo(rule, Sets.<AbstractRule> newHashSet())) for (MatcherTransition afterReturn : caller.getOutgoingAfterReturn()) afterReturn.addPattern(state, pattern); } }