public SerializerActionCfg(Action context) { super(GrammarUtil.getGrammar(context)); this.context = context; }
public SerializerParserRuleCfg(ParserRule context) { super(GrammarUtil.getGrammar(context)); this.context = context; }
@Override public EClassifier caseKeyword(Keyword object) { EDataType eString = GrammarUtil.findEString(GrammarUtil.getGrammar(object)); if (eString != null) return eString; // nowhere imported - use the instance from the registry return EcorePackage.Literals.ESTRING; }
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; }
public String getId(AbstractRule rule) { if (!(rule instanceof ParserRule)) throw new IllegalArgumentException("Unsupported context rule: " + rule); return GrammarUtil.getGrammar(rule).getName()+"."+rule.getName(); }
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; }
public String getId(AbstractElement element) { if (!(element instanceof Keyword)) throw new IllegalArgumentException("Unsupported context element: " + element); return GrammarUtil.getGrammar(element).getName()+".kw_"+((Keyword) element).getValue(); }
protected String getQualifiedName(final AbstractRule rule) { String _name = GrammarUtil.getGrammar(rule).getName(); String _plus = (_name + "."); String _name_1 = rule.getName(); return (_plus + _name_1); }
protected AbstractRule findWhitespaceRule(AbstractElement ele) { for (int i = ruleCalls.size() - 1; i >= 0; i--) { AbstractRule rule = ruleCalls.get(i).getRule(); if (rule instanceof ParserRule) { ParserRule pr = (ParserRule) rule; if (pr.isDefinesHiddenTokens()) { for (AbstractRule hidden : pr.getHiddenTokens()) if (isWhitespaceRule(hidden)) return hidden; return null; } } } if (ruleCalls.isEmpty()) return findWhitespaceRule(GrammarUtil.getGrammar(ele)); return findWhitespaceRule(GrammarUtil.getGrammar(ruleCalls.get(0))); }
@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); }
public boolean usesXImportSection(final Grammar grammar) { final Set<AbstractRule> usedRules = CollectionLiterals.<AbstractRule>newHashSet(); new UsedRulesFinder(usedRules).compute(grammar); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((Objects.equal(it.getName(), "XImportSection") && Objects.equal(GrammarUtil.getGrammar(it).getName(), "org.eclipse.xtext.xbase.Xtype"))); }; return IterableExtensions.<AbstractRule>exists(usedRules, _function); } }
protected void validateReferencedMetamodel(final ReferencedMetamodel ref) { if (((ref.getEPackage() != null) && (!ref.getEPackage().eIsProxy()))) { return; } final EReference eref = XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE; final List<INode> nodes = NodeModelUtils.findNodesForFeature(ref, eref); String _xifexpression = null; boolean _isEmpty = nodes.isEmpty(); if (_isEmpty) { _xifexpression = "(unknown)"; } else { _xifexpression = NodeModelUtils.getTokenText(nodes.get(0)); } final String refName = _xifexpression; final String grammarName = GrammarUtil.getGrammar(ref).getName(); final String msg = ((((("The EPackage " + refName) + " in grammar ") + grammarName) + " could not be found. ") + "You might want to register that EPackage in your workflow file."); throw new IllegalStateException(msg); }
/** * Returns all grammars from the hierarchy that are used from rules of this grammar. */ protected List<Grammar> getEffectivelyUsedGrammars(final Grammar grammar) { final Function1<AbstractRule, Grammar> _function = (AbstractRule it) -> { return GrammarUtil.getGrammar(it); }; final Function1<Grammar, Boolean> _function_1 = (Grammar it) -> { return Boolean.valueOf((it != grammar)); }; return IterableExtensions.<Grammar>toList(IterableExtensions.<Grammar>toSet(IterableExtensions.<Grammar>filter(ListExtensions.<AbstractRule, Grammar>map(GrammarUtil.allRules(grammar), _function), _function_1))); }
@Override protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { TypeReference _grammarAccess = GrammarAccessExtensions.this.getGrammarAccess(GrammarUtil.getGrammar(ele)); _builder.append(_grammarAccess); _builder.append(".INSTANCE."); String _gaRuleElementAccessor = GrammarAccessExtensions.this.gaRuleElementAccessor(ele); _builder.append(_gaRuleElementAccessor); } };
public EClassifierInfo getInfo(TypeRef typeRef) { if (typeRef.getClassifier() == null) return null; EClassifierInfo result = getInfo(typeRef.getMetamodel(), typeRef.getClassifier().getName()); if (result == null) { Grammar declaringGrammar = GrammarUtil.getGrammar(typeRef); if (grammar.equals(declaringGrammar)) return result; for(EClassifierInfos parent: parents) { result = parent.getInfo(typeRef); if (result != null) return result; } } return result; }
public void inspectKeywordHidesTerminalRule(Keyword keyword) { AbstractRule container = GrammarUtil.containingRule(keyword); if (container instanceof TerminalRule) return; Grammar grammar = GrammarUtil.getGrammar(container); List<TerminalRule> rules = GrammarUtil.allTerminalRules(grammar); for(TerminalRule rule: rules) { AbstractElement element = rule.getAlternatives(); if (element instanceof Keyword && Strings.isEmpty(element.getCardinality())) { String value = ((Keyword) element).getValue(); if (value.equals(keyword.getValue())) acceptor.acceptError("The keyword '" + value + "' hides the terminal rule " + rule.getName()+ ".", keyword, XtextPackage.Literals.KEYWORD__VALUE, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); } } }
private void collectClassInfosOf(EClassifierInfos target, EPackage referencedEPackage, AbstractMetamodelDeclaration metaModel, boolean generated) { for (EClassifier eClassifier : referencedEPackage.getEClassifiers()) { if (eClassifier instanceof EClass) { EClass eClass = (EClass) eClassifier; EClassifierInfo info = EClassifierInfo.createEClassInfo(eClass, generated, getGeneratedEPackageURIs(), GrammarUtil.getGrammar(metaModel)); target.addInfo(metaModel, eClassifier.getName(), info); } else if (eClassifier instanceof EDataType) { EDataType eDataType = (EDataType) eClassifier; EClassifierInfo info = EClassifierInfo.createEDataTypeInfo(eDataType, generated); target.addInfo(metaModel, eClassifier.getName(), info); } } }
public boolean checkCrossReferenceTerminal(RuleCall call) { if (call.getRule() != null && call.getRule().getType() != null) { EClassifier type = call.getRule().getType().getClassifier(); EDataType dataType = GrammarUtil.findEString(GrammarUtil.getGrammar(call)); if (dataType == null) dataType = EcorePackage.Literals.ESTRING; if (type != null && dataType != type) { error( "The rule '" + call.getRule().getName() + "' is not valid for a cross reference since it does not return "+ "an EString. You'll have to wrap it in a data type rule.", call, null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); return true; } } return false; }
private EClassifierInfo findOrCreateEClassifierInfo(TypeRef typeRef, String name, boolean createIfMissing) throws TransformationException { if (typeRef.getClassifier() != null && typeRef.getMetamodel() == null) throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot find metamodel for type '" + typeRef.getClassifier().getName() + "'", typeRef); EClassifierInfo info = eClassifierInfos.getInfo(typeRef); if (info == null) { // we assumend EString for terminal rules and datatype rules, so // we have to do a look up in super grammar EDataType dataType = GrammarUtil.findEString(GrammarUtil.getGrammar(typeRef)); if (dataType != null && typeRef.getClassifier() == dataType) { info = eClassifierInfos.getInfoOrNull(typeRef); if (info != null) return info; } if (createIfMissing) info = createEClassifierInfo(typeRef, name); } return info; }