protected Map<Grammar, Integer> getInheritanceDistance(Grammar grammar) { Map<Grammar, Integer> result = Maps.newHashMap(); Grammar current = grammar; int distance = 0; while (current != null) { result.put(current, distance); current = current.getUsedGrammars().isEmpty() ? null : current.getUsedGrammars().get(0); distance++; } return result; }
private static void collectAllUsedGrammars(List<Grammar> grammars, Grammar grammar) { grammars.addAll(grammar.getUsedGrammars()); for (Grammar g : grammar.getUsedGrammars()) collectAllUsedGrammars(grammars, g); }
@Check(CheckType.FAST) public void checkGrammarUsesMaxOneOther(Grammar grammar) { if (grammar.getUsedGrammars().size() > 1) { for(int i = 1; i < grammar.getUsedGrammars().size(); i++) { error( "You may not use more than one other grammar.", XtextPackage.Literals.GRAMMAR__USED_GRAMMARS, i); } } }
@Check(CheckType.FAST) public void checkGrammarRecursiveReference(Grammar grammar) { Set<Grammar> visitedGrammars = Sets.newHashSet(grammar); for (int i = 0; i < grammar.getUsedGrammars().size(); i++) { Grammar usedGrammar = grammar.getUsedGrammars().get(i); if(!doCheckGrammarRecursiveReference(grammar, usedGrammar, i, visitedGrammars)) return; } }
protected void collectAllUsedGrammars(Grammar grammar, Collection<Grammar> visited) { if (!visited.add(grammar)) return; for(Grammar usedGrammar: grammar.getUsedGrammars()) { collectAllUsedGrammars(usedGrammar, visited); } }
protected List<GeneratedMetamodel> getInheritedGeneratedMetamodels(ReferencedMetamodel metamodel) { List<GeneratedMetamodel> allGeneratedMetamodels = new ArrayList<GeneratedMetamodel>(); Grammar grammar = GrammarUtil.getGrammar(metamodel); Set<Grammar> visited = Sets.newHashSet(); for (Grammar usedGrammar : grammar.getUsedGrammars()) Iterables.addAll(allGeneratedMetamodels, getAllGeneratedMetamodels(usedGrammar, visited)); if (allGeneratedMetamodels.isEmpty()) return Collections.emptyList(); return allGeneratedMetamodels; }
protected void updateOverriddenRules(Grammar grammar) { if (grammar.getUsedGrammars().isEmpty()) return; Map<String, AbstractRule> rulePerName = new HashMap<String, AbstractRule>(grammar.getRules().size()); for (AbstractRule rule : grammar.getRules()) rulePerName.put(rule.getName(), rule); Set<Grammar> visitedGrammars = new HashSet<Grammar>(); visitedGrammars.add(grammar); for (Grammar usedGrammar : grammar.getUsedGrammars()) { updateOverriddenRules(usedGrammar, rulePerName, visitedGrammars); } }
private Iterable<GeneratedMetamodel> getAllGeneratedMetamodels(Grammar grammar, Set<Grammar> visited) { Iterable<GeneratedMetamodel> result = Iterables.filter(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class); for (Grammar gr : grammar.getUsedGrammars()) { if (visited.add(gr)) result = Iterables.concat(result, getAllGeneratedMetamodels(gr, visited)); } return result; }
protected AbstractRule findWhitespaceRule(Grammar grammar) { for (AbstractRule hidden : grammar.getHiddenTokens()) if (isWhitespaceRule(hidden)) return hidden; if (!grammar.getUsedGrammars().isEmpty()) return findWhitespaceRule(grammar.getUsedGrammars().get(0)); return null; }
public static Grammar getNonTerminalsSuperGrammar(final Grammar grammar) { final Function1<Grammar, Boolean> _function = (Grammar it) -> { String _name = it.getName(); return Boolean.valueOf((!Objects.equal(_name, GrammarUtil2.TERMINALS))); }; return IterableExtensions.<Grammar>findFirst(grammar.getUsedGrammars(), _function); } }
protected void getInheritedContainmentReferences(final Grammar grammar, final Multimap<EClass, EReference> type2ref, final Set<Grammar> visitedGrammars) { visitedGrammars.add(grammar); EList<Grammar> _usedGrammars = grammar.getUsedGrammars(); for (final Grammar usedGrammar : _usedGrammars) { boolean _contains = visitedGrammars.contains(usedGrammar); boolean _not = (!_contains); if (_not) { this.getLocallyAssignedContainmentReferences(usedGrammar, type2ref); this.getInheritedContainmentReferences(usedGrammar, type2ref, visitedGrammars); } } }
protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { Grammar grammar = grammarProvider.getGrammar(this); while (grammar != null) { if ("org.eclipse.xtext.xbase.Xtype".equals(grammar.getName())) { return grammar; } List<Grammar> grammars = grammar.getUsedGrammars(); if (!grammars.isEmpty()) { grammar = grammars.iterator().next(); } else { return null; } } return grammar; }
private boolean isReferencedByUsedGrammar(GeneratedMetamodel generatedMetamodel, String nsURI) { final Grammar grammar = GrammarUtil.getGrammar(generatedMetamodel); if (grammar != null) { final Set<Grammar> visitedGrammars = Sets.newHashSet(grammar); for (Grammar usedGrammar: grammar.getUsedGrammars()) { if (isReferencedByUsedGrammar(usedGrammar, nsURI, visitedGrammars)) return true; } } return false; }
protected void updateOverriddenRules(Grammar grammar, Map<String, AbstractRule> rulePerName, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return; updateOverriddenRules(grammar, rulePerName); for (Grammar usedGrammar : grammar.getUsedGrammars()) { updateOverriddenRules(usedGrammar, rulePerName, visitedGrammars); } }
private static void collectAllRules(Grammar grammar, List<AbstractRule> result, Set<Grammar> visitedGrammars, Set<String> knownRulenames) { if (!visitedGrammars.add(grammar)) return; for (AbstractRule rule : grammar.getRules()) { if (knownRulenames.add(rule.getName())) { result.add(rule); } } for (Grammar usedGrammar : grammar.getUsedGrammars()) { collectAllRules(usedGrammar, result, visitedGrammars, knownRulenames); } }
private void collectEClassInfosOfUsedGrammars() { Set<Grammar> visitedGrammars = Sets.newLinkedHashSet(); visitedGrammars.add(grammar); for(Grammar usedGrammar: grammar.getUsedGrammars()) { EClassifierInfos parent = createClassifierInfosFor(usedGrammar, visitedGrammars); if (parent != null) this.getEClassifierInfos().addParent(parent); } }
private static void collectAllMetamodelDeclarations(Grammar grammar, List<AbstractMetamodelDeclaration> result, Set<Pair<String, String>> knownAliases, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return; for (AbstractMetamodelDeclaration decl : grammar.getMetamodelDeclarations()) { if (decl.getEPackage() == null) result.add(decl); else if (knownAliases.add(getURIAliasPair(decl))) { result.add(decl); } } for (Grammar usedGrammar : grammar.getUsedGrammars()) collectAllMetamodelDeclarations(usedGrammar, result, knownAliases, visitedGrammars); }
private boolean containsAnyParserRule(Grammar g, Set<Grammar> visited) { if (!visited.add(g)) return false; for (AbstractRule rule : g.getRules()) { if (rule instanceof ParserRule && !GrammarUtil.isDatatypeRule((ParserRule) rule)) return true; } for (Grammar used : g.getUsedGrammars()) { if (containsAnyParserRule(used, visited)) return true; } return false; }
@Override public Void caseGrammar(Grammar object) { if (!visitedGrammars.add(object)) return null; if (object.isDefinesHiddenTokens()) for(AbstractRule rule: object.getHiddenTokens()) doSwitch(rule); for(Grammar grammar: object.getUsedGrammars()) { caseGrammar(grammar); } return null; }
private boolean doCheckGrammarRecursiveReference(Grammar grammarToCheck, Grammar currentGrammar, int idx, Set<Grammar> visitedGrammars) { if (Strings.equal(grammarToCheck.getName(), currentGrammar.getName())) { error("Invalid recursive reference of grammar.", XtextPackage.Literals.GRAMMAR__USED_GRAMMARS, idx); return false; } if (!visitedGrammars.add(currentGrammar)) return true; for(Grammar usedGrammar: currentGrammar.getUsedGrammars()) { if (!doCheckGrammarRecursiveReference(grammarToCheck, usedGrammar, idx, visitedGrammars)) return false; } return true; }