@Override public AbstractElement getRoot() { return context.getAlternatives(); } }
@Override public Boolean caseParserRule(ParserRule object) { if (object.getAlternatives() != null) return doSwitch(object.getAlternatives()); return true; }
@Override public Boolean caseParserRule(ParserRule object) { return object == child || (rules.add(object) && doSwitch(object.getAlternatives())); } }.doSwitch(parent);
protected Boolean getApproximatedResult(ParserRule object) { if (object.getAlternatives() == null) return true; Iterator<?> contents = EcoreUtil.getAllContents(object.getAlternatives(), true); return !Iterators.filter(contents, new Predicate<Object>() { public boolean apply(Object input) { return input instanceof Assignment || input instanceof Action; } }).hasNext(); }
/** * @since 2.0 */ public void init(ParserRule rule) { lastState = nfaProvider.getNFA(rule.getAlternatives()); }
@Override public Boolean caseParserRule(ParserRule object) { if (!validatedRules.add(object)) return Boolean.FALSE; return doSwitch(object.getAlternatives()); }
@Override public Boolean caseParserRule(ParserRule object) { return rules.add(object) && doSwitch(object.getAlternatives()); } }.doSwitch(element);
@Override protected Boolean doInspect(ParserRule rule) { return doSwitch(rule.getAlternatives()); }
protected List<AbstractElement> _contentsAsList(final ParserRule it) { return this.contentsAsList(it.getAlternatives()); }
public ISyntaxConstraint getConstraint(ParserRule rule) { ISyntaxConstraint e = rule2element.get(rule); if (e == null) { if (isValidateableRule(rule)) e = createElement(rule.getAlternatives()); else e = INVALID_RULE; rule2element.put(rule, e); } return e != INVALID_RULE ? e : null; }
protected ConstraintElement createConstraintElement(ParserRule rule, EClass requiredType, Set<Object> visited) { if (!visited.add(rule)) return INVALID; if (GrammarUtil.containsAssignedAction(rule)) { ActionFilterState start = nfaProvider.getNFA(rule.getAlternatives()); return createConstraintElement(rule, start, requiredType, false, visited); } else { return createConstraintElement(rule, rule.getAlternatives(), requiredType, visited); } }
@Override public Void caseParserRule(ParserRule object) { if (usedRules.add(object)) { if (object.getAlternatives() != null) doSwitch(object.getAlternatives()); if (object.isDefinesHiddenTokens()) for(AbstractRule rule: object.getHiddenTokens()) doSwitch(rule); } return null; }
@Override protected boolean canInspect(ParserRule rule) { if (GrammarUtil.isDatatypeRule(rule) || rule.getAlternatives() == null) return false; return super.canInspect(rule); }
@Override public Boolean caseParserRule(ParserRule object) { if (GrammarUtil.isDatatypeRule(object)) return Boolean.FALSE; return doSwitch(object.getAlternatives()); }
@Override public Boolean caseParserRule(ParserRule object) { if (GrammarUtil.isDatatypeRule(object)) return Boolean.FALSE; return doSwitch(object.getAlternatives()); }
@Override public Boolean caseParserRule(ParserRule object) { if (visitedRules.isEmpty()) { visitedRules.add(object); return object.getAlternatives() != null && doSwitch(object.getAlternatives()); } final TypeRef typeRef = object.getType(); if (typeRef == null || typeRef.getClassifier() == null) { throw new IllegalStateException("checks are only allowed for linked grammars. Rule: " + object.getName()); } if (!visitedRules.add(object)) return true; Boolean result = GrammarUtil.isDatatypeRule(object); visitedRules.remove(object); return result; }
private void deriveFeatures(ParserRule rule) throws TransformationException { EClassifierInfo classInfo = findEClassifierInfo(rule); if (classInfo == null) throw new TransformationException(TransformationErrorCode.NoSuchTypeAvailable, "No type available for rule " + rule.getName(), rule); Xtext2EcoreInterpretationContext context = new Xtext2EcoreInterpretationContext(eClassifierInfos, classInfo); if (rule.getAlternatives() != null) // might happen due to syntax errors in the document deriveFeatures(context, rule.getAlternatives()); }
@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); }
/** * 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))); } } } }
@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); }