@Override public Boolean caseAbstractRule(AbstractRule object) { if (!validatedRules.add(object)) return Boolean.FALSE; ruleStack.add(object); Boolean result = object.getAlternatives() == null ? Boolean.FALSE : doSwitch(object.getAlternatives()); ruleStack.remove(object); return result; }
@Override public AbstractElement getRoot() { return GrammarUtil.containingRule(context).getAlternatives(); } }
protected Result doInspect(RuleType rule) { visitedRules.add(rule); Result r = doSwitch(rule.getAlternatives()); return r; }
protected void calculatePrefixes(AbstractRule rule) { final List<String> result = new ArrayList<String>(3); createCalculator(result).doSwitch(rule.getAlternatives()); this.result = result.toArray(new String[result.size()]); }
protected boolean containsRelevantElement(AbstractElement ele) { Iterator<EObject> i = Iterators.concat(Collections.singleton(ele).iterator(), ele.eAllContents()); while (i.hasNext()) { EObject o = i.next(); if (o instanceof Action || o instanceof Assignment) return true; if (o instanceof RuleCall && containsRelevantElement(((RuleCall) o).getRule().getAlternatives())) return true; } return false; }
public AbstractElement getCall(AbstractElement ele) { switch (ele.eClass().getClassifierID()) { case XtextPackage.RULE_CALL: return ((RuleCall) ele).getRule().getAlternatives(); default: return null; } }
public AbstractElement getRoot() { return grammar.getRules().size() > 0 ? grammar.getRules().get(0).getAlternatives() : null; }
protected Map<TreeConstState, Integer> getEndDistances() { AbstractElement rootEle = containingRule(element).getAlternatives(); TreeConstState root = builder.getState(rootEle); if (root.endDistances == null) root.endDistances = Maps.newLinkedHashMap(); return root.endDistances; }
@Override protected String getUnassignedRuleCallToken(RuleCall ruleCall, INode node) { if (node != null) return node.getText().trim(); AbstractRule rule = ruleCall.getRule(); if (GrammarUtil.isDatatypeRule(rule)) { if (rule.getAlternatives() instanceof Keyword) return ((Keyword) rule.getAlternatives()).getValue(); if (rule.getAlternatives() instanceof Alternatives) for (AbstractElement ele : ((Alternatives) rule.getAlternatives()).getElements()) if (ele instanceof Keyword) ((Keyword) ele).getValue(); } return ""; }
@Override public Boolean caseAbstractRule(AbstractRule object) { if (!checkFurther(object)) return result; if (!visiting.add(object)) return Boolean.FALSE; if (visited.containsKey(object)) { visiting.remove(object); return visited.get(object); } EObject wasGrammarElement = grammarElement; Boolean result = doSwitch(object.getAlternatives()); visiting.remove(object); if (isExpectedGrammarElement(wasGrammarElement)) // we store the result per grammarElement for performance reasons visited.put(object, result); return result; }
@SuppressWarnings({ "rawtypes", "unchecked" }) public List<T> getIncommingWithoutRuleCalls() { List<T> result = Lists.newArrayList(); AbstractElement rootEle = containingRule(element).getAlternatives(); ((AbstractNFAState) builder.getState(rootEle)).collectReferencesToThis(this, Sets.newHashSet(), result); return result; }
protected List<AbstractElement> getAbstractElements(EObject obj) { if (obj instanceof AbstractElement) return Collections.singletonList((AbstractElement) obj); if (obj instanceof AbstractRule) { AbstractRule rule = (AbstractRule) obj; if (rule.getType().getClassifier() instanceof EClass) return Collections.singletonList(rule.getAlternatives()); List<AbstractElement> result = Lists.newArrayList(); for (RuleCall rc : grammarAccess.findRuleCalls(rule)) { CrossReference cr = GrammarUtil.containingCrossReference(rc); result.add(cr == null ? rc : cr); } return result; } return null; }
@Override public Boolean caseRuleCall(RuleCall object) { AbstractRule rule = object.getRule(); if (rule instanceof TerminalRule) { ruleCalls.put((TerminalRule) rule, object); } else { boolean result = doSwitch(rule.getAlternatives()); if (result) { return true; } } return GrammarUtil.isOptionalCardinality(object); }
public Set<EClass> getTypesForContext(EObject context) { Set<EClass> result = Sets.newHashSet(); if (context instanceof AbstractElement) { AbstractElement ele = (AbstractElement) context; collectTypesForContext(nfaProvider2.getNFA(ele), result, false, false, Sets.newHashSet()); } else if (context instanceof AbstractRule) { AbstractElement ele = ((AbstractRule) context).getAlternatives(); collectTypesForContext(nfaProvider2.getNFA(ele), result, true, false, Sets.newHashSet()); if (GrammarUtil.isOptionalCardinality(ele)) result.add(null); } else throw new RuntimeException("This is not a valid context: " + EmfFormatter.objPath(context)); return result; }
public boolean isParserRuleCallOptional() { if (ruleCallOptional == null) ruleCallOptional = isParserRuleCall() && isOptional(((RuleCall) element).getRule().getAlternatives()); return ruleCallOptional; } }
protected Digraph drawRule(AbstractRule rule, Digraph d) { if (rule.getType().getClassifier() instanceof EClass) drawAbstractElementTree(rule.getAlternatives(), d); return d; }
public Status getStatus() { if (distances == null) { AbstractElement rootEle = containingRule(element).getAlternatives(); builder.getState(rootEle).initStatus(); } return getStatusInternal(); }
@Inject public void setGrammarAccess(SARLGrammarAccess access) { this.mlRule = access.getML_COMMENTRule(); this.slRule = access.getSL_COMMENTRule(); for (AbstractElement element : ((Group) this.mlRule.getAlternatives()).getElements()) { if (element instanceof Keyword && Strings.isEmpty(this.mlStartSymbols)) { this.mlStartSymbols = ((Keyword) element).getValue(); } else if (element instanceof UntilToken && Strings.isEmpty(this.mlEndTagSymbols)) { this.mlEndTagSymbols = ((Keyword) ((UntilToken) element).getTerminal()).getValue(); } } AbstractRule slRule = access.getSL_COMMENTRule(); for (AbstractElement element : ((Group) slRule.getAlternatives()).getElements()) { if (element instanceof Keyword) { this.slStartSymbols = ((Keyword) element).getValue().trim(); break; } } }
@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; }
protected CharSequence paramConfig(final AbstractElement it) { StringConcatenation _builder = new StringConcatenation(); { if ((((GrammarUtil.containingRule(it).getAlternatives() == it) && ParserRule.class.isInstance(GrammarUtil.containingRule(it))) && (!((ParserRule) AntlrGrammarGenUtil.<AbstractRule>getOriginalElement(GrammarUtil.containingRule(it))).getParameters().isEmpty()))) { _builder.append(", "); AbstractRule _containingRule = GrammarUtil.containingRule(it); int _parameterConfig = AntlrGrammarGenUtil.getParameterConfig(((ParserRule) _containingRule)); _builder.append(_parameterConfig); _builder.newLineIfNotEmpty(); } } return _builder; }