public <S, E, T, P extends Nfa<S>> P create(Production<E, T> production, FollowerFunction<E> ff, NfaFactory<P, S, ? super T> factory) { return create(production, ff, new GetToken<E, T>(production), factory, null, null); }
public <S> void removeOrphans(Nfa<S> nfa) { Map<S, Integer> distances = distanceToFinalStateMap(nfa); for (S s : collect(nfa)) { Iterator<S> i = nfa.getFollowers(s).iterator(); while (i.hasNext()) if (!distances.containsKey(i.next())) i.remove(); } }
public <S> Map<S, Integer> distanceToStateMap(Nfa<S> nfa, Predicate<S> matches) { return distanceFromStateMap(inverse(nfa), matches); }
@Override public boolean equals(Object obj) { if (obj == null || obj.getClass() != getClass()) return false; return new NfaUtil().equalsIgnoreOrder(this, (SerializerPDA) obj); }
public <S extends Comparable<S>> Nfa<S> sort(Nfa<S> nfa) { Map<S, List<S>> followerMap = Maps.newLinkedHashMap(); for (S state : new NfaUtil().collect(nfa)) { ArrayList<S> followers = Lists.newArrayList(nfa.getFollowers(state)); Collections.sort(followers); followerMap.put(state, followers); } return new NFAImpl<S>(nfa.getStart(), nfa.getStop(), followerMap); }
public Nfa<ISemState> getNFA(EObject context, EClass type) { Pair<EObject, EClass> key = Tuples.create(context, type); Nfa<ISemState> nfa = resultCache.get(key); if (nfa != null) return nfa; NfaUtil util = new NfaUtil(); SynAbsorberNfaAdapter synNfa = new SynAbsorberNfaAdapter(pdaProvider.getPDA(context, type)); // System.out.println(new NfaFormatter().format(synNfa)); Map<ISynAbsorberState, Integer> distanceMap = util.distanceToFinalStateMap(synNfa); nfa = util.create(util.sort(synNfa, distanceMap), new SemStateFactory()); // util.sortInplace(nfa, distanceMap); if (type != null) initContentValidationNeeded(type, nfa); initRemainingFeatures(nfa.getStop(), util.inverse(nfa), Sets.<ISemState> newHashSet()); initOrderIDs(nfa); // System.out.println(new NfaFormatter().format(nfa)); resultCache.put(key, nfa); return nfa; }
public <S, ITERABLE extends Iterable<? extends S>> S find(Nfa<S> nfa, Iterable<S> starts, Predicate<S> matcher) { Set<S> visited = Sets.newHashSet(); for (S s : starts) { S r = find(nfa, s, matcher, visited); if (r != null) return r; } return null; }
public <S, P, R, D extends Pda<S, P>> D filterEdges(Pda<S, P> pda, Traverser<? super Pda<S, P>, S, R> traverser, PdaFactory<D, S, P, S> factory) { Map<S, Integer> distances = new NfaUtil().distanceToFinalStateMap(pda); return filterEdges(pda, traverser, distances, factory); }
protected Nfa<ProdElement> getParameterNfa(String syntax) { AssignedProduction prod = new AssignedProduction(syntax); FollowerFunctionImpl<ProdElement, String> ff = new FollowerFunctionImpl<ProdElement, String>(prod); ProdElement start = prod.new ProdElement(ElementType.TOKEN); ProdElement stop = prod.new ProdElement(ElementType.TOKEN); Nfa<ProdElement> result = new NfaUtil().create(prod, ff, start, stop); return result; }
if (stops == e.getKey()) result.append(" (stop)"); if (!new NfaUtil().canReachFinalState(nfa, e.getKey())) result.append(" (no connection to final state!)"); result.append("\n");
protected <S> void collect(Nfa<S> nfa, S state, Set<S> visited) { if (!visited.add(state)) return; for (S s : nfa.getFollowers(state)) collect(nfa, s, visited); }
public <S> boolean equalsIgnoreOrder(Nfa<S> nfa1, Nfa<S> nfa2) { return equalsIgnoreOrder(nfa1, nfa2, new Function<S, Object>() { public Object apply(S from) { return from; } }); }
public <S, P> Nfa<S> filterUnambiguousPaths(Pda<S, P> pda) { Map<S, List<S>> followers = Maps.newLinkedHashMap(); Map<S, Integer> distanceMap = nfaUtil.distanceToFinalStateMap(pda); filterUnambiguousPaths(pda, pda.getStart(), distanceMap, followers); return new NfaUtil.NFAImpl<S>(pda.getStart(), pda.getStop(), followers); }
public <S, COMP extends Comparable<COMP>> Nfa<S> sort(Nfa<S> nfa, Map<S, COMP> comparator) { return sort(nfa, new MappedComparator<S, COMP>(comparator)); }
public <S, ITERABLE extends Iterable<? extends S>> S find(Nfa<S> nfa, Iterable<S> starts, Predicate<S> matcher) { Set<S> visited = Sets.newHashSet(); for (S s : starts) { S r = find(nfa, s, matcher, visited); if (r != null) return r; } return null; }
if (previous == null) return factory.create(pda.getStart(), pda.getStop()); Map<S, Integer> distances = new NfaUtil().distanceToFinalStateMap(pda); MappedComparator<S, Integer> distanceComp = new MappedComparator<S, Integer>(distances); trace.push(newItem(pda, distanceComp, distances, pda.getStart(), previous));