/** * @since 2.0 */ protected EClass getConstructedType(AbstractElement ele) { if (ele instanceof Action) return (EClass) ((Action) ele).getType().getClassifier(); if (GrammarUtil.containingAssignment(ele) != null) return (EClass) GrammarUtil.containingRule(ele).getType().getClassifier(); return null; }
private boolean isEnumLiteral(EObject object, EStructuralFeature feature) { if (feature == XtextPackage.eINSTANCE.getEnumLiteralDeclaration_EnumLiteral()) { EnumRule rule = GrammarUtil.containingEnumRule(object); return rule.getType() == null || rule.getType().getClassifier() == null; } return false; }
public static boolean isEObjectRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof ParserRule && calledRule.getType().getClassifier() instanceof EClass; } return false; }
protected String getQualifiedName(final AbstractRule rule) { String _name = GrammarUtil.getGrammar(rule).getName(); String _plus = (_name + "."); String _name_1 = rule.getName(); return (_plus + _name_1); }
@Override public AbstractElement getCall(AbstractElement ele) { if (ele instanceof RuleCall && !GrammarUtil.isAssigned(ele) && ((RuleCall) ele).getRule().getType().getClassifier() instanceof EClass) return ((RuleCall) ele).getRule().getAlternatives(); return null; }
private AbstractRule getTemplateRule() { if (templateRule == null) templateRule = GrammarUtil.findRuleForName(grammarAccess.getGrammar(), "Codetemplate"); return templateRule; }
@Override public boolean filter(AbstractElement grammarElement) { if (grammarElement.eContainer() instanceof AbstractRule) return false; if (EcoreUtil2.getContainerOfType(grammarElement.eContainer(), Assignment.class) != null) return true; return false; }
public boolean apply(RuleCall input) { return ((ParserRule) input.getRule()).isDefinesHiddenTokens(); } });
public EClass getCrossReferenceType() { if (element == null) return null; CrossReference cr = GrammarUtil.containingCrossReference(element); if (cr == null) return null; return (EClass) cr.getType().getClassifier(); }
protected String getFeatureName() { if (element instanceof Action) return ((Action) element).getFeature(); Assignment ass = GrammarUtil.containingAssignment(element); if (ass != null) return ass.getFeature(); return null; }
/** * @since 2.0 */ public static boolean isEObjectRule(EObject grammarElement) { return grammarElement instanceof ParserRule && ((ParserRule) grammarElement).getType().getClassifier() instanceof EClass; }
protected Digraph drawRule(AbstractRule rule, Digraph d) { if (rule.getType().getClassifier() instanceof EClass) drawAbstractElementTree(rule.getAlternatives(), d); return d; }
private boolean isAlternativeWithEmptyPath(AbstractElement abstractElement) { if (abstractElement instanceof Alternatives) { Alternatives alternatives = (Alternatives) abstractElement; for(AbstractElement path: alternatives.getElements()) { if (GrammarUtil.isOptionalCardinality(path)) return true; } } return false; } }
protected String getAssignmentOperator() { if (element instanceof Action) return ((Action) element).getOperator(); Assignment ass = GrammarUtil.containingAssignment(element); if (ass != null) return ass.getOperator(); return null; }
@Override public AbstractElement getRoot() { return GrammarUtil.containingRule(context).getAlternatives(); } }
@Override public boolean filter(AbstractElement ele) { // never filter root elements if (!(ele.eContainer() instanceof AbstractElement)) return false; if (ele instanceof Assignment || ele instanceof Action) return false; if (GrammarUtil.isUnassignedEObjectRuleCall(ele)) return false; return true; }
protected boolean isConsumingElement() { return element instanceof Assignment || (element instanceof RuleCall && ((RuleCall) element).getRule().getType().getClassifier() instanceof EClass) || element instanceof Action; }
protected TerminalRule getWSRule() { // FIXME: make this configurable return (TerminalRule) GrammarUtil.findRuleForName(grammar.getGrammar(), "WS"); }
public static boolean isDatatypeRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof ParserRule && calledRule.getType().getClassifier() instanceof EDataType; } return false; }
public boolean isParserRuleCall() { return element instanceof RuleCall && ((RuleCall) element).getRule().getType().getClassifier() instanceof EClass; }