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 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; }
public String getLanguageID(final Grammar grammar) { return grammar.getName(); } }
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; }
@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; }
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; }
protected void updateOverriddenRules(Grammar grammar, Map<String, AbstractRule> rulePerName) { if (grammar.isDefinesHiddenTokens()) { updateHiddenTokens(grammar.getHiddenTokens(), rulePerName); } for (AbstractRule rule : grammar.getRules()) { if (rule instanceof ParserRule && ((ParserRule) rule).isDefinesHiddenTokens()) { updateHiddenTokens(((ParserRule) rule).getHiddenTokens(), rulePerName); } } final List<RuleCall> allRuleCalls = EcoreUtil2.getAllContentsOfType(grammar, RuleCall.class); for (RuleCall call : allRuleCalls) { if (call.getRule() != null) { AbstractRule rule = rulePerName.get(call.getRule().getName()); if (rule != null) call.setRule(rule); } } }
protected void doGenerateXtendInferrer() { final TypeReference firstRuleType = TypeReference.typeRef(GenModelUtil2.getJavaTypeName(IterableExtensions.<AbstractRule>head(this.getLanguage().getGrammar().getRules()).getType().getClassifier(), this.getLanguage().getGrammar().eResource().getResourceSet())); TypeReference _jvmModelInferrer = this.getJvmModelInferrer(); StringConcatenationClient _client = new StringConcatenationClient() {
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public Grammar getLanguage() { if (language != null && language.eIsProxy()) { InternalEObject oldLanguage = (InternalEObject)language; language = (Grammar)eResolveProxy(oldLanguage); if (language != oldLanguage) { if (eNotificationRequired()) eNotify(new ENotificationImpl(this, Notification.RESOLVE, TemplatesPackage.CODETEMPLATES__LANGUAGE, oldLanguage, language)); } } return language; }
public static String getLanguageId(Grammar g) { return g.getName(); }
private static void collectAllUsedGrammars(List<Grammar> grammars, Grammar grammar) { grammars.addAll(grammar.getUsedGrammars()); for (Grammar g : grammar.getUsedGrammars()) collectAllUsedGrammars(grammars, g); }
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); }
EClassifier _classifier = IterableExtensions.<AbstractRule>head(this.getGrammar().getRules()).getType().getClassifier(); ResourceSet _resourceSet = this.getGrammar().eResource().getResourceSet(); final TypeReference rootType = new TypeReference(((EClass) _classifier), _resourceSet); TypeReference _exampleRuntimeTest = this.exampleRuntimeTest();
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public Grammar getLanguage() { if (language != null && language.eIsProxy()) { InternalEObject oldLanguage = (InternalEObject)language; language = (Grammar)eResolveProxy(oldLanguage); if (language != oldLanguage) { if (eNotificationRequired()) eNotify(new ENotificationImpl(this, Notification.RESOLVE, TemplatesPackage.CODETEMPLATES__LANGUAGE, oldLanguage, language)); } } return language; }
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; }
public String caseGrammar(Grammar obj) { return PREFIX + obj.getName(); }