protected String _getConcreteSyntaxRuleName(final CrossReference crossReference) { String _xifexpression = null; AbstractElement _terminal = crossReference.getTerminal(); if ((_terminal instanceof RuleCall)) { _xifexpression = this.getConcreteSyntaxRuleName(crossReference.getTerminal()); } return _xifexpression; }
@Override public Void caseCrossReference(CrossReference object) { if (object.getTerminal() != null) return doSwitch(object.getTerminal()); return null; }
@Check public void checkCrossReferenceTerminal(CrossReference reference) { if (reference.getTerminal() != null) { if (reference.getTerminal() instanceof RuleCall) { RuleCall call = (RuleCall) reference.getTerminal(); checkCrossReferenceTerminal(call); } } }
protected boolean hasIdRule(final CrossReference crossRef) { AbstractElement _terminal = crossRef.getTerminal(); if ((_terminal instanceof RuleCall)) { AbstractElement _terminal_1 = crossRef.getTerminal(); final String ruleName = ((RuleCall) _terminal_1).getRule().getName(); return ((Objects.equal(ruleName, "IdOrSuper") || Objects.equal(ruleName, "ValidID")) || Objects.equal(ruleName, "FeatureCallID")); } return false; }
@Override public Boolean caseCrossReference(CrossReference object) { if (object == stopElement) return true; return doSwitch(object.getTerminal()); }
@Override public Boolean caseCrossReference(CrossReference object) { return doSwitch(object.getTerminal()); }
protected String _assignmentEbnf(final CrossReference it, final Assignment assignment, final AntlrOptions options, final boolean supportActions) { return this.crossrefEbnf(it.getTerminal(), it, supportActions); }
/** * @param grammarElement * may be any crossreferencable element, i.e. a keyword or a rulecall */ public String getRuleNameFrom(EObject grammarElement) { if (!(grammarElement instanceof Keyword || grammarElement instanceof RuleCall || grammarElement instanceof CrossReference)) throw new IllegalArgumentException("grammarElement is of type: '" + grammarElement.eClass().getName() + "'"); AbstractRule rule = null; EObject elementToUse = grammarElement; if (grammarElement instanceof CrossReference) elementToUse = ((CrossReference) grammarElement).getTerminal(); if (elementToUse instanceof RuleCall) rule = ((RuleCall) elementToUse).getRule(); return rule != null ? rule.getName() : null; }
public Iterable<AbstractElement> getSequentialChildren(AbstractElement ele) { switch (ele.eClass().getClassifierID()) { case XtextPackage.GROUP: return ((Group) ele).getElements(); case XtextPackage.ASSIGNMENT: return Collections.singleton(((Assignment) ele).getTerminal()); case XtextPackage.CROSS_REFERENCE: return Collections.singleton(((CrossReference) ele).getTerminal()); default: return null; } }
@Override public Boolean caseCrossReference(CrossReference object) { Boolean result = doSwitch(object.getTerminal()); return result || GrammarUtil.isOptionalCardinality(object); }
@Override public Boolean caseCrossReference(CrossReference object) { // Do not create duplicate errors if (shouldTraverse(object)) { pushChecked(object); if (object.getTerminal() != null) doSwitch(object.getTerminal()); popChecked(object); } return Boolean.FALSE; }
public AbstractRule getTokenRule(INode node) { if (node == null) return null; EObject element = node.getGrammarElement(); if (element instanceof AbstractRule) return (AbstractRule) element; if (element instanceof CrossReference) element = ((CrossReference) element).getTerminal(); if (element instanceof RuleCall) return ((RuleCall) element).getRule(); return null; }
protected void lookupCrossReference(CrossReference crossReference, EReference reference, ContentAssistContext contentAssistContext, ICompletionProposalAcceptor acceptor, Predicate<IEObjectDescription> filter) { String ruleName = null; if (crossReference.getTerminal() instanceof RuleCall) { ruleName = ((RuleCall) crossReference.getTerminal()).getRule().getName(); } lookupCrossReference(contentAssistContext.getCurrentModel(), reference, acceptor, filter, getProposalFactory(ruleName, contentAssistContext)); }
@Override public Boolean caseCrossReference(CrossReference object) { if (!checkFurther(object)) return result; if (doSwitch(object.getTerminal())) return true; if (GrammarUtil.isMultipleCardinality(object)) { if (!checkFurther(object)) return result; if (doSwitch(object.getTerminal())) return true; } return Boolean.FALSE; }
@Override public Boolean caseCrossReference(CrossReference object) { if (!checkFurther(object)) return result; if (doSwitch(object.getTerminal())) return true; if (GrammarUtil.isMultipleCardinality(object)) { if (!checkFurther(object)) return result; if (doSwitch(object.getTerminal())) return true; } return Boolean.FALSE; }
protected AbstractRule binaryOperationPrecedence(final EObject op) { final INode node = this._nodeModelAccess.nodeForFeature(op, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE); if (((node != null) && (node.getGrammarElement() instanceof CrossReference))) { EObject _grammarElement = node.getGrammarElement(); final AbstractElement terminal = ((CrossReference) _grammarElement).getTerminal(); if ((terminal instanceof RuleCall)) { return ((RuleCall)terminal).getRule(); } } return null; }
@Override protected void afterCreateAndSetProxy(EObject obj, INode node, EReference eRef, CrossReference xref, IDiagnosticProducer diagnosticProducer) { AbstractElement terminal = xref.getTerminal(); if (!(terminal instanceof RuleCall)) { throw new IllegalArgumentException(String.valueOf(xref)); } AbstractRule rule = ((RuleCall) terminal).getRule(); try { String tokenText = NodeModelUtils.getTokenText(node); valueConverterService.toValue(tokenText, rule.getName(), node); } catch(ValueConverterException e) { diagnosticProducer.addDiagnostic(new DiagnosticMessage(e.getMessage(), Severity.ERROR, Diagnostic.SYNTAX_DIAGNOSTIC, Strings.EMPTY_ARRAY)); } }
public IScope create(IScope parent, AbstractElement syntaxElement) { if (syntaxElement instanceof CrossReference) { return create(parent, ((CrossReference) syntaxElement).getTerminal()); } if (syntaxElement instanceof RuleCall) { AbstractRule rule = ((RuleCall) syntaxElement).getRule(); if (GrammarUtil.isDatatypeRule(rule)) { List<String> values = getEnumeratedValues((ParserRule) rule); if (values.isEmpty()) { return parent; } return new SyntaxFilteredScope(parent, values); } } return parent; }
public boolean isToken(INode node) { if (node instanceof ILeafNode) return !((ILeafNode) node).isHidden(); AbstractRule rule; if (node.getGrammarElement() instanceof AbstractRule) rule = (AbstractRule) node.getGrammarElement(); else if (node.getGrammarElement() instanceof RuleCall) rule = ((RuleCall) node.getGrammarElement()).getRule(); else if (node.getGrammarElement() instanceof CrossReference && ((CrossReference) node.getGrammarElement()).getTerminal() instanceof RuleCall) rule = ((RuleCall) ((CrossReference) node.getGrammarElement()).getTerminal()).getRule(); else rule = null; if (rule instanceof ParserRule) return GrammarUtil.isDatatypeRule((ParserRule) rule); if (rule instanceof EnumRule) return true; return false; }
protected Triple<INode, AbstractElement, EObject> findNext(INode node, boolean prune) { INode current = next(node, prune); while (current != null) { if (current instanceof ILeafNode && ((ILeafNode) current).isHidden()) { current = next(current, true); continue; } EObject ge = current.getGrammarElement(); if (ge instanceof AbstractElement && isEObjectNode(current)) return Tuples.create(current, (AbstractElement) ge, getEObjectNodeEObject(current)); else if (GrammarUtil.isAssigned(ge) && !GrammarUtil.isEObjectRuleCall(ge)) { if (ge instanceof CrossReference) return Tuples.create(current, ((CrossReference) ge).getTerminal(), null); else return Tuples.create(current, (AbstractElement) ge, null); } else current = next(current, false); } return null; }