public static Collection<EPackage> allEPackagesToValidate(final Grammar _this) { Iterable<TypeRef> allTypeRefs = concat(transform(allParserRules(_this), new Function<ParserRule, Iterable<TypeRef>>() { public Iterable<TypeRef> apply(ParserRule from) { return EcoreUtil2.eAllOfType(from, TypeRef.class); } })); return newLinkedHashSet(transform(filter(allTypeRefs, new Predicate<TypeRef>() { public boolean apply(TypeRef input) { return !(input.eContainer() instanceof CrossReference) && input.getClassifier() instanceof EClass; } }), new Function<TypeRef, EPackage>() { public EPackage apply(TypeRef from) { return from.getClassifier().getEPackage(); } })); }
protected boolean hasParameterizedRules(final Grammar grammar) { List<ParserRule> _allParserRules = GrammarUtil.allParserRules(grammar); for (final ParserRule rule : _allParserRules) { boolean _isEmpty = rule.getParameters().isEmpty(); boolean _not = (!_isEmpty); if (_not) { return true; } } return false; }
protected int getElementID(AbstractElement ele) { if (elementIDCache == null) { elementIDCache = Maps.newHashMap(); int counter = 0; for (ParserRule pr : GrammarUtil.allParserRules(grammar.getGrammar())) for (AbstractElement e : EcoreUtil2.getAllContentsOfType(pr, AbstractElement.class)) elementIDCache.put(e, counter++); } return elementIDCache.get(ele); }
@Inject public Collector(IGrammarAccess grammarAccess) { Grammar grammar = grammarAccess.getGrammar(); List<ParserRule> parserRules = GrammarUtil.allParserRules(grammar); List<UnorderedGroup> groups = Lists.newArrayList(); for(ParserRule rule: parserRules) { Iterator<EObject> iter = rule.eAllContents(); while(iter.hasNext()) { EObject next = iter.next(); if (next instanceof UnorderedGroup) { groups.add((UnorderedGroup) next); } } } this.groups = ImmutableList.copyOf(groups); }
protected boolean containsUnorderedGroup(final Grammar grammar) { List<ParserRule> _allParserRules = GrammarUtil.allParserRules(grammar); for (final ParserRule rule : _allParserRules) { boolean _hasNext = Iterators.<UnorderedGroup>filter(rule.eAllContents(), UnorderedGroup.class).hasNext(); if (_hasNext) { return true; } } return false; }
public List<EObject> getAllContexts(Grammar grammar) { List<EObject> result = Lists.newArrayList(); for (ParserRule pr : GrammarUtil.allParserRules(grammar)) if (GrammarUtil.isEObjectRule(pr)) { result.add(pr); for (Action action : GrammarUtil.containedActions(pr)) if (GrammarUtil.isAssignedAction(action)) result.add(action); } return result; }
/** * inits the grammar order tree */ @Inject private void init() { if (grammarTree.isEmpty()) { grammarTree.clear(); List<ParserRule> parserRules = GrammarUtil.allParserRules(grammarAccess.getGrammar()); for (ParserRule rule : parserRules) { List<Action> action = GrammarUtil.containedActions(rule); List<Alternatives> alternatives = EcoreUtil2.getAllContentsOfType(rule.getAlternatives(), Alternatives.class); if (action.size() == 1 && alternatives.size() > 0) { grammarTree.put(action.get(0).getType().getClassifier(), getPriorityTree(alternatives.get(0))); } } } }
public List<IConstraintContext> getConstraints(Grammar context) { List<IConstraintContext> result = cache.get(context); if (result == null) { result = Lists.newArrayList(); for (ParserRule parserRule : GrammarUtil.allParserRules(context)) if (parserRule.getType().getClassifier() instanceof EClass) { result.add(getConstraints(parserRule)); for (Action action : GrammarUtil.containedActions(parserRule)) if (action.getFeature() != null) result.add(getConstraints(action)); } filterDuplicateConstraintsAndSetNames(context, result); cache.put(context, result); } return result; }
public static Set<String> getAllKeywords(Grammar g) { Set<String> kws = new HashSet<String>(); List<ParserRule> rules = allParserRules(g); for (ParserRule parserRule : rules) { List<Keyword> list = typeSelect(eAllContentsAsList(parserRule), Keyword.class); for (Keyword keyword : list) { kws.add(keyword.getValue()); } } List<EnumRule> enumRules = allEnumRules(g); for (EnumRule enumRule : enumRules) { List<Keyword> list = typeSelect(eAllContentsAsList(enumRule), Keyword.class); for (Keyword keyword : list) { kws.add(keyword.getValue()); } } return kws; }
private BiMap<CharSequence, String> createKeywordMap(Grammar grammar) { List<ParserRule> parserRules = GrammarUtil.allParserRules(grammar); List<EnumRule> enumRules = GrammarUtil.allEnumRules(grammar); Iterator<EObject> iter = Iterators.concat(
protected void registerContextTypes(IGrammarAccess grammarAccess, Provider<XtextTemplateContextType> ctxTypeProvider) { List<ParserRule> parserRules = GrammarUtil.allParserRules(grammarAccess.getGrammar()); List<XtextTemplateContextType> allContextTypes = Lists.newArrayList(); for (ParserRule parserRule : parserRules) { XtextTemplateContextType type = ctxTypeProvider.get(); type.setName(parserRule.getName()); type.setId(getId(parserRule)); allContextTypes.add(type); List<Keyword> keywords = EcoreUtil2.getAllContentsOfType(parserRule, Keyword.class); for (Keyword keyword : keywords) { String value = getId(keyword); if (value!=null) { type = ctxTypeProvider.get(); type.setName("Keyword '"+keyword.getValue()+"'"); type.setId(value); allContextTypes.add(type); } } } Collections.sort(allContextTypes); for (XtextTemplateContextType templateContextType: allContextTypes) { addContextType(templateContextType); } }
/** * @since 2.4 * @nooverride This method is not intended to be re-implemented or extended by clients. * @noreference This method is not intended to be referenced by clients. */ protected void registerEFactoryConverters(Map<String, IValueConverter<Object>> converters) { for (ParserRule parserRule : allParserRules(getGrammar())) { if (isDatatypeRule(parserRule) && !converters.containsKey(parserRule.getName())) { EDataType datatype = (EDataType) parserRule.getType().getClassifier(); converters.put(parserRule.getName(), new EFactoryValueConverter(datatype)); } } for (TerminalRule terminalRule : allTerminalRules(getGrammar())) { if (!terminalRule.isFragment()) { String terminalRuleName = terminalRule.getName(); if (!converters.containsKey(terminalRuleName)) { converters.put(terminalRuleName, defaultTerminalConverterFactory.create(terminalRule)); } } } }
public NamedSerializationContextProvider(final Grammar grammar) { final Function1<Pair<Integer, ParserRule>, Pair<ParserRule, Integer>> _function = (Pair<Integer, ParserRule> it) -> { ParserRule _value = it.getValue(); Integer _key = it.getKey(); return Pair.<ParserRule, Integer>of(_value, _key); }; this.rules = CollectionLiterals.<ParserRule, Integer>newHashMap(((Pair<? extends ParserRule, ? extends Integer>[])Conversions.unwrapArray(IterableExtensions.<Pair<Integer, ParserRule>, Pair<ParserRule, Integer>>map(IterableExtensions.<ParserRule>indexed(GrammarUtil.allParserRules(grammar)), _function), Pair.class))); }
StringConcatenation _builder = new StringConcatenation(); List<ParserRule> _allParserRules = GrammarUtil.allParserRules(g); List<EnumRule> _allEnumRules = GrammarUtil.allEnumRules(g); Iterable<AbstractRule> _plus = Iterables.<AbstractRule>concat(_allParserRules, _allEnumRules);
public void collectAbstractElements(Grammar grammar, EStructuralFeature feature, IFollowElementAcceptor followElementAcceptor) { for (Grammar superGrammar : grammar.getUsedGrammars()) { collectAbstractElements(superGrammar, feature, followElementAcceptor); } EClass declarator = feature.getEContainingClass(); for (ParserRule rule : GrammarUtil.allParserRules(grammar)) { for (Assignment assignment : GrammarUtil.containedAssignments(rule)) { if (assignment.getFeature().equals(feature.getName())) { EClassifier classifier = GrammarUtil.findCurrentType(assignment); EClassifier compType = EcoreUtil2.getCompatibleType(declarator, classifier); if (compType == declarator) { followElementAcceptor.accept(assignment); } } } } }
protected CharSequence compileRules(final Grammar it, final AntlrOptions options) { StringConcatenation _builder = new StringConcatenation(); { List<ParserRule> _allParserRules = GrammarUtil.allParserRules(it); List<EnumRule> _allEnumRules = GrammarUtil.allEnumRules(it); final Function1<AbstractRule, Boolean> _function = (AbstractRule rule) -> { return Boolean.valueOf(this._grammarAccessExtensions.isCalled(rule, it)); }; Iterable<AbstractRule> _filter = IterableExtensions.<AbstractRule>filter(Iterables.<AbstractRule>concat(_allParserRules, _allEnumRules), _function); for(final AbstractRule rule : _filter) { _builder.newLine(); CharSequence _compileRule = this.compileRule(rule, it, options); _builder.append(_compileRule); _builder.newLineIfNotEmpty(); } } { boolean _isCombinedGrammar = this.isCombinedGrammar(); if (_isCombinedGrammar) { CharSequence _compileTerminalRules = this.compileTerminalRules(it, options); _builder.append(_compileTerminalRules); _builder.newLineIfNotEmpty(); } } return _builder; }
_builder.newLine(); if (((!IterableExtensions.isEmpty(Iterables.<UnorderedGroup>filter(Iterables.<EObject>concat(ListExtensions.<ParserRule, List<EObject>>map(GrammarUtil.allParserRules(it), ((Function1<ParserRule, List<EObject>>) (ParserRule it_1) -> { return EcoreUtil2.eAllContentsAsList(it_1); }))), UnorderedGroup.class))) && options.isBacktrack())) {
_builder.newLine(); if (((!IterableExtensions.isEmpty(Iterables.<UnorderedGroup>filter(Iterables.<EObject>concat(ListExtensions.<ParserRule, List<EObject>>map(GrammarUtil.allParserRules(it), ((Function1<ParserRule, List<EObject>>) (ParserRule it_1) -> { return EcoreUtil2.eAllContentsAsList(it_1); }))), UnorderedGroup.class))) && options.isBacktrack())) {
_builder.append("\t\t"); _builder.append("return \""); ParserRule _originalElement = AntlrGrammarGenUtil.<ParserRule>getOriginalElement(IterableExtensions.<ParserRule>head(GrammarUtil.allParserRules(it))); String _name = ((AbstractRule) _originalElement).getName(); _builder.append(_name, "\t\t");
_builder.append(" \t"); _builder.append("return \""); String _name = AntlrGrammarGenUtil.<ParserRule>getOriginalElement(IterableExtensions.<ParserRule>head(GrammarUtil.allParserRules(it))).getName(); _builder.append(_name, " \t"); _builder.append("\";");