public AbstractElementAlias getSyntax() { Pda<ISynState, RuleCall> pathToTarget = getPathToTarget(); return new NfaToProduction().nfaToGrammar(pathToTarget, new GetGrammarElement(), new GrammarAliasFactory()); }
public <ELEMENT, STATE, TOKEN> ELEMENT nfaToGrammar(Nfa<STATE> nfa, Function<STATE, TOKEN> state2token, Comparator<? super TOKEN> order, ProductionFactory<ELEMENT, TOKEN> grammarFactory) { StateAliasNfa<TOKEN> states = createNfa(nfa, state2token); boolean changed = true; changed = createAlternative(states); changed |= createOptional(states); changed |= createMany(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); changed |= createGroups(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); changed |= mergeOptionalIntoMany(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); changed |= mergeAlternativeMultiples(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); Pair<Integer, StateAlias<TOKEN>> splitState = findSplitState(states.getStart(), 0, Sets.<StateAlias<TOKEN>> newHashSet()); if (splitState != null) { changed = true; splitState(splitState.getSecond()); root = removeStartAndStop(nfa, state2token, root); normalize(root); if (order != null) root.sort(new ElementAliasComparator<TOKEN>(order));
public <ELEMENT, STATE, TOKEN> ELEMENT nfaToGrammar(Nfa<STATE> nfa, Function<STATE, TOKEN> state2token, ProductionFactory<ELEMENT, TOKEN> grammarFactory) { StateAliasNfa<TOKEN> states = createNfa(nfa, state2token); boolean changed = true; changed = createAlternative(states); changed |= createOptional(states); changed |= createMany(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); changed |= createGroups(states.getStart(), Sets.<StateAlias<TOKEN>> newHashSet()); Pair<Integer, StateAlias<TOKEN>> splitState = findSplitState(states.getStart(), 0, Sets.<StateAlias<TOKEN>> newHashSet()); if (splitState != null) { changed = true; splitState(splitState.getSecond());
protected <T> Pair<Integer, StateAlias<T>> findSplitState(StateAlias<T> state, Integer depth, Set<StateAlias<T>> visited) { if (!visited.add(state)) return null; Pair<Integer, StateAlias<T>> result; if (state.getOutgoing().size() > 0 && state.getIncoming().size() > 0 && state.getOutgoing().size() + state.getIncoming().size() > 2) result = Tuples.create(depth, state); else result = null; for (StateAlias<T> out : state.getOutgoing()) { Pair<Integer, StateAlias<T>> cand = findSplitState(out, depth + 1, visited); if (cand != null && (result == null || isPreferredSplitState(cand, result))) result = cand; } return result; }
protected <T> boolean createGroups(StateAlias<T> state, Set<StateAlias<T>> visited) { if (!visited.add(state)) return false; boolean created = false; if (state.getOutgoing().size() == 1 && state.getOutgoing().iterator().next().getIncoming().size() == 1) { StateAlias<T> follower = state.getOutgoing().iterator().next(); if (state != follower) { createGroup(state, follower); created = true; } } for (StateAlias<T> out : state.getOutgoing()) { if (createGroups(out, visited)) created = true; } return created; }
public <ELEMENT, STATE, TOKEN> ELEMENT nfaToGrammar(Nfa<STATE> nfa, Function<STATE, TOKEN> state2token, ProductionFactory<ELEMENT, TOKEN> grammarFactory) { return nfaToGrammar(nfa, state2token, null, grammarFactory); }
protected <T> boolean createMany(StateAlias<T> state, Set<StateAlias<T>> visited) { if (!visited.add(state)) return false; boolean created = false; if (state.getOutgoing().contains(state)) { state.getElement().setMany(true); state.getOutgoing().remove(state); state.getIncoming().remove(state); created = true; } for (StateAlias<T> out : state.getOutgoing()) { if (createMany(out, visited)) created = true; } return created; }
protected <T> Pair<Integer, StateAlias<T>> findSplitState(StateAlias<T> state, Integer depth, Set<StateAlias<T>> visited) { if (!visited.add(state)) return null; Pair<Integer, StateAlias<T>> result; if (state.getOutgoing().size() > 0 && state.getIncoming().size() > 0 && state.getOutgoing().size() + state.getIncoming().size() > 2) result = Tuples.create(depth, state); else result = null; for (StateAlias<T> out : state.getOutgoing()) { Pair<Integer, StateAlias<T>> cand = findSplitState(out, depth + 1, visited); if (cand != null && (result == null || isPreferredSplitState(cand, result))) result = cand; } return result; }
protected <T> boolean createGroups(StateAlias<T> state, Set<StateAlias<T>> visited) { if (!visited.add(state)) return false; boolean created = false; if (state.getOutgoing().size() == 1 && state.getOutgoing().iterator().next().getIncoming().size() == 1) { StateAlias<T> follower = state.getOutgoing().iterator().next(); if (state != follower) { createGroup(state, follower); created = true; } } for (StateAlias<T> out : state.getOutgoing()) { if (createGroups(out, visited)) created = true; } return created; }
public <ELEMENT, STATE> ELEMENT nfaToGrammar(Nfa<STATE> nfa, ProductionFactory<ELEMENT, STATE> grammarFactory) { return nfaToGrammar(nfa, Functions.<STATE> identity(), grammarFactory); }
protected <T> boolean createMany(StateAlias<T> state, Set<StateAlias<T>> visited) { if (!visited.add(state)) return false; boolean created = false; if (state.getOutgoing().contains(state)) { state.getElement().setMany(true); state.getOutgoing().remove(state); state.getIncoming().remove(state); created = true; } for (StateAlias<T> out : state.getOutgoing()) { if (createMany(out, visited)) created = true; } return created; }
public ISerializationDiagnostic createBacktrackingFailedDiagnostic(SerializableObject semanticObject, EObject context, Nfa<ISemState> nfa) { GrammarElementTitleSwitch ele2str = new GrammarElementTitleSwitch().showAssignments().setValueForNull(null); ProductionStringFactory<AbstractElement> grammarFactory = new ProductionStringFactory<AbstractElement>(ele2str); String grammar = new NfaToProduction().nfaToGrammar(nfa, new GetGrammarEle(), grammarFactory); StringBuilder msg = new StringBuilder(); msg.append("Could not serialize EObject via backtracking.\n"); msg.append("Constraint: " + grammar + "\n"); msg.append(semanticObject.getValuesString()); return new SerializationDiagnostic(BACKTRACKING_FAILED, semanticObject.getEObject(), context, msg.toString()); }
public <ELEMENT, STATE> ELEMENT nfaToGrammar(Nfa<STATE> nfa, ProductionFactory<ELEMENT, STATE> grammarFactory) { return nfaToGrammar(nfa, Functions.<STATE> identity(), grammarFactory); }
public AbstractElementAlias getShortSyntax() { Nfa<ISynState> path = new NfaUtil().filter(getPathToTarget(), new Filter()); return new NfaToProduction().nfaToGrammar(path, new GetGrammarElement(), new GrammarAliasFactory()); }
public List<AbstractElementAlias> getAmbiguousSyntaxes() { if (ambiguousSyntaxes != null) return ambiguousSyntaxes; if (!isSyntacticallyAmbiguous()) return ambiguousSyntaxes = Collections.emptyList(); ambiguousSyntaxes = Lists.newArrayList(); Nfa<ISynState> nfa = new PdaUtil().filterUnambiguousPaths(getPathToTarget()); nfa = new NfaUtil().filter(nfa, new Filter()); AbstractElementAlias syntax = new NfaToProduction().nfaToGrammar(nfa, new GetGrammarElement(), new GrammarAliasFactory()); if (syntax instanceof GroupAlias) { GroupAlias group = (GroupAlias) syntax; for (AbstractElementAlias child : group.getChildren()) if (child.isMany() || child.isOptional() || child instanceof AlternativeAlias) ambiguousSyntaxes.add(child); } else ambiguousSyntaxes.add(syntax); return ambiguousSyntaxes; }