protected boolean hasProductionRules(final Grammar grammar) { AbstractRule firstRule = grammar.getRules().get(0); return ((firstRule instanceof ParserRule) && (!GrammarUtil.isDatatypeRule(((ParserRule) firstRule)))); }
public void inspect(Grammar grammar) { this.inspectedGrammar = grammar; for(AbstractRule rule: grammar.getRules()) { if (!validatedRules.contains(rule)) { // different entry points yield different error messages Set<AbstractRule> storedRules = validatedRules; validatedRules = Sets.newHashSet(); doSwitch(rule); storedRules.addAll(validatedRules); storedRules = validatedRules; } } }
protected List<EObject> findPathToImportSection() { EList<AbstractRule> rules = grammarAccess.getGrammar().getRules(); if(!rules.isEmpty() && rules.get(0) instanceof ParserRule) { LinkedList<EObject> pathToImportSection = newLinkedList(); if(internalFindPathToImportSection(pathToImportSection, new HashSet<ParserRule>(), rules.get(0))) { return pathToImportSection; } } return null; }
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); } }
@Inject private void initEntryRule(IGrammarAccess grammar) { initializeFor(grammar.getGrammar().getRules().get(0)); }
protected ParserRule getFirstParserRule(Grammar grammar) { for (AbstractRule r : grammar.getRules()) if (isParserRule(r)) return (ParserRule) r; throw new RuntimeException("Grammar " + grammar.getName() + " contains no parser rules"); }
protected EObject getRootContext() { for (AbstractRule rule : grammar.getGrammar().getRules()) if (GrammarUtil.isEObjectRule(rule)) return rule; throw new RuntimeException("There is no parser rule in the grammar."); }
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); } }
public void caseGrammar(Grammar object) { for(AbstractRule rule: object.getRules()) unload(rule); unload(object); }
@Override public Boolean caseGrammar(Grammar grammar) { UsedRulesFinder usedRulesFinder = new UsedRulesFinder(usedRules); usedRulesFinder.compute(grammar); this.inspectedGrammar = grammar; for(AbstractRule rule: grammar.getRules()) { if (!validatedRules.contains(rule) && usedRules.contains(rule)) { doSwitch(rule); } } return Boolean.FALSE; }
@Override protected boolean canInspect(ParserRule rule) { if (GrammarUtil.getGrammar(rule).getRules().get(0) != rule) return false; if (GrammarUtil.isDatatypeRule(rule) || rule.getAlternatives() == null) return false; return super.canInspect(rule); }
@Override protected boolean canInspect(ParserRule rule) { // special treatment of first rule if (GrammarUtil.getGrammar(rule).getRules().get(0) == rule) return false; if (GrammarUtil.isDatatypeRule(rule) || rule.getAlternatives() == null) return false; return super.canInspect(rule); }
private Iterable<String> computeFQFeatureNames(final Grammar g) { final Function1<Assignment, String> _function = (Assignment it) -> { return this.getFQFeatureName(it); }; List<String> _map = ListExtensions.<Assignment, String>map(GrammarUtil.containedAssignments(g), _function); final Function1<AbstractRule, String> _function_1 = (AbstractRule it) -> { return this.getFQFeatureName(it); }; List<String> _map_1 = ListExtensions.<AbstractRule, String>map(g.getRules(), _function_1); return Iterables.<String>concat(_map, _map_1); }
protected List<AbstractRule> getExportedRulesFromGrammar() { List<AbstractRule> _xblockexpression = null; { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isExported(it) && alreadyCollected.add(it.getType().getClassifier()))); }; _xblockexpression = IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); } return _xblockexpression; }
/** * @since 2.14 */ protected List<AbstractRule> getDeprecatedRulesFromGrammar() { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isDeprecated(it) && alreadyCollected.add(it.getType().getClassifier()))); }; return IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); }
@Inject protected void register(final EValidatorRegistrar registrar, final IGrammarAccess grammarAccess) { final AbstractRule entryRule = IterableExtensions.<AbstractRule>head(grammarAccess.getGrammar().getRules()); if ((entryRule instanceof ParserRule)) { registrar.register(((ParserRule)entryRule).getType().getClassifier().getEPackage(), this); } }
private EClassifierInfo findOrCreateEClassifierInfo(AbstractRule rule) throws TransformationException { final TypeRef typeRef = getOrComputeReturnType(rule); if (typeRef == null) throw new TransformationException(TransformationErrorCode.NoSuchTypeAvailable, "Cannot create type for unnamed rule.", rule); if (typeRef.getMetamodel() != null && typeRef.getMetamodel().getEPackage() == null) throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot create type without declared package.", typeRef); return findOrCreateEClassifierInfo(typeRef, rule.getName(), grammar.getRules().contains(rule)); }
public List<T> getAllIncoming() { for (Adapter a : element.eResource().eAdapters()) if (a instanceof IsInitializedMarker && ((IsInitializedMarker) a).builder == builder) return getIncoming(); element.eResource().eAdapters().add(new IsInitializedMarker(builder)); for (EObject root : element.eResource().getContents()) if (root instanceof Grammar) for (AbstractRule rule : ((Grammar) root).getRules()) if (rule.getType().getClassifier() instanceof EClass) for (AbstractElement ele : EcoreUtil2.eAllOfType(rule, AbstractElement.class)) if (!builder.filter(ele)) builder.getState(ele).getOutgoing(); return getIncoming(); }