protected String _localVar(final AbstractElement it) { String _xblockexpression = null; { final ParserRule rule = GrammarUtil.containingParserRule(it); final int index = this.contentsAsList(rule).indexOf(it); _xblockexpression = ("otherlv_" + Integer.valueOf(index)); } return _xblockexpression; }
public void accept(AbstractElement element) { ParserRule rule = GrammarUtil.containingParserRule(element); if (rule == null || !GrammarUtil.isDatatypeRule(rule)) result.add(element); } };
public ParserRule getRule() { return GrammarUtil.containingParserRule(rule.getGrammarElement()); }
public String localVar(final Assignment it, final AbstractElement terminal) { String _feature = it.getFeature(); String _plus = ("lv_" + _feature); String _plus_1 = (_plus + "_"); int _indexOf = this.contentsAsList(GrammarUtil.containingParserRule(it)).indexOf(it); String _plus_2 = (_plus_1 + Integer.valueOf(_indexOf)); String _plus_3 = (_plus_2 + "_"); int _indexOf_1 = EcoreUtil2.eAllContentsAsList(it).indexOf(terminal); return (_plus_3 + Integer.valueOf(_indexOf_1)); }
public INode getContainingDatatypeRuleNode(INode node) { INode result = node; EObject grammarElement = result.getGrammarElement(); if (grammarElement != null) { ParserRule parserRule = GrammarUtil.containingParserRule(grammarElement); while (parserRule != null && GrammarUtil.isDatatypeRule(parserRule)) { result = result.getParent(); grammarElement = result.getGrammarElement(); parserRule = GrammarUtil.containingParserRule(grammarElement); } } return result; }
private EObject getRelevantGrammarRule(final INode node) { if (!node2grammarRule.containsKey(node)) { EObject grammarElement = node.getGrammarElement(); if (attachToPrevious.contains(grammarElement)) { INode prev = getPreviousNonWSSibling(node); grammarElement = prev.getGrammarElement(); } // RuleCalls invoking a rule which creates an element will // become an Action if (grammarElement instanceof Action) { grammarElement = containingParserRule(grammarElement); } node2grammarRule.put(node, grammarElement); } return node2grammarRule.get(node); }
public INode getContainingDatatypeRuleNode(INode node) { INode result = node; EObject grammarElement = result.getGrammarElement(); if (grammarElement != null) { ParserRule parserRule = GrammarUtil.containingParserRule(grammarElement); while (parserRule != null && GrammarUtil.isDatatypeRule(parserRule)) { result = result.getParent(); grammarElement = result.getGrammarElement(); parserRule = GrammarUtil.containingParserRule(grammarElement); } } return result; }
public void computeFollowElements(Collection<FollowElement> followElements, final IFollowElementAcceptor followElementAcceptor) { FollowElementCalculator calculator = feCalculatorProvider.get(); calculator.acceptor = element -> { ParserRule rule = GrammarUtil.containingParserRule(element); if (rule == null || !GrammarUtil.isDatatypeRule(rule)) followElementAcceptor.accept(element); }; for(FollowElement element: followElements) { computeFollowElements(calculator, element); } }
protected String adjustRuleName(String ruleName, Param param) { AbstractElement elementToParse = param.elementToParse; Set<Parameter> context = getAssignedParameters(elementToParse, param.paramStack); if (!context.isEmpty()) { ParserRule containingRule = GrammarUtil.containingParserRule(elementToParse); String antlrRuleName = ruleNames.getAntlrRuleName(containingRule); int len = antlrRuleName.length(); if (antlrRuleName.startsWith("rule")) { len += 2; // rule__XYZ instead of ruleXYZ } int config = getParameterConfig(context); String result = ruleNames.getAntlrRuleName(containingRule, config) + ruleName.substring(len); return result; } return ruleName; }
protected String _localVar(final RuleCall it) { String _name = AntlrGrammarGenUtil.<AbstractRule>getOriginalElement(it.getRule()).getName(); String _plus = ("this_" + _name); String _plus_1 = (_plus + "_"); int _indexOf = this.contentsAsList(GrammarUtil.containingParserRule(it)).indexOf(it); return (_plus_1 + Integer.valueOf(_indexOf)); }
protected void lookupCrossReference(CrossReference crossReference, ContentAssistContext contentAssistContext, ICompletionProposalAcceptor acceptor, Predicate<IEObjectDescription> filter) { ParserRule containingParserRule = GrammarUtil.containingParserRule(crossReference); if (!GrammarUtil.isDatatypeRule(containingParserRule)) { EReference ref = GrammarUtil.getReference(crossReference); lookupCrossReference(crossReference, ref, contentAssistContext, acceptor, filter); } }
protected String checkUnconsumed(AbstractToken token, IEObjectConsumer instanceDescription) { if (token.getGrammarElement() == null) return null; boolean finalNode = nfaProvider.getNFA(token.getGrammarElement()).isEndState(); if (!finalNode || instanceDescription.isConsumed()) return null; ParserRule parserRule = GrammarUtil.containingParserRule(token.getGrammarElement()); StringBuffer b = new StringBuffer(); b.append("Can not leave rule '"); b.append(parserRule.getName()); b.append("' since the current object '"); b.append(instanceDescription.getEObject().eClass().getName()); b.append("' has features with unconsumed values: "); Map<EStructuralFeature, Integer> unconsumedTokens = instanceDescription.getUnconsumed(); int i = 0; for (Map.Entry<EStructuralFeature, Integer> unconsumedFeature2NumberEntry : unconsumedTokens.entrySet()) { b.append("'"); b.append(unconsumedFeature2NumberEntry.getKey().getName()); b.append("':"); b.append(unconsumedFeature2NumberEntry.getValue()); if (++i != unconsumedTokens.size()) b.append(", "); } return b.toString(); }
protected void lookupCrossReference(CrossReference crossReference, ContentAssistContext contentAssistContext, ICompletionProposalAcceptor acceptor, Predicate<IEObjectDescription> filter, Function<IEObjectDescription, ICompletionProposal> proposalFactory) { ParserRule containingParserRule = GrammarUtil.containingParserRule(crossReference); if (!GrammarUtil.isDatatypeRule(containingParserRule)) { EReference ref = GrammarUtil.getReference(crossReference); lookupCrossReference(crossReference, ref, acceptor, filter, proposalFactory); } }
/** * Returns the invocation of a ParserRule Parameter as Java expression. */ public String gaRuleParameterAccessor(final Parameter parameter) { final ParserRule rule = GrammarUtil.containingParserRule(parameter); final int index = rule.getParameters().indexOf(parameter); String _gaRuleAccessor = this.gaRuleAccessor(rule); String _plus = (_gaRuleAccessor + ".getParameters().get("); String _plus_1 = (_plus + Integer.valueOf(index)); String _plus_2 = (_plus_1 + "/*"); String _name = parameter.getName(); String _plus_3 = (_plus_2 + _name); return (_plus_3 + "*/)"); }
private String getFQFeatureName(final Assignment a) { String _firstUpper = StringExtensions.toFirstUpper(GrammarUtil.containingParserRule(a).getName()); String _plus = (_firstUpper + "_"); String _firstUpper_1 = StringExtensions.toFirstUpper(a.getFeature()); return (_plus + _firstUpper_1); }
/** * @since 2.0 */ protected void initStream(AbstractToken token, WsMergerStream out) { AbstractElement rootMostElement = null; if (!token.getTokensForSemanticChildren().isEmpty()) { for (AbstractToken t : Lists.reverse(token.getTokensForSemanticChildren())) if (t.getGrammarElement() != null) { rootMostElement = t.getGrammarElement(); break; } } else if (token.getGrammarElement() != null) { rootMostElement = token.getGrammarElement(); } if (rootMostElement != null) { ParserRule rootRule = GrammarUtil.containingParserRule(rootMostElement); out.init(rootRule); } }
protected CharSequence createModelElementForParent(final EObject grammarElement) { StringConcatenation _builder = new StringConcatenation(); _builder.append("createModelElementForParent(grammarAccess."); String _grammarElementAccess = this._grammarAccessExtensions.grammarElementAccess(AntlrGrammarGenUtil.<ParserRule>getOriginalElement(GrammarUtil.containingParserRule(grammarElement))); _builder.append(_grammarElementAccess); _builder.append(")"); return _builder; }
@Override public void completeAssignment(Assignment assignment, ContentAssistContext contentAssistContext, ICompletionProposalAcceptor acceptor) { ParserRule parserRule = GrammarUtil.containingParserRule(assignment); String methodName = "complete" + Strings.toFirstUpper(parserRule.getName()) + "_" + Strings.toFirstUpper(assignment.getFeature()); invokeMethod(methodName, acceptor, contentAssistContext.getCurrentModel(), assignment, contentAssistContext); }
protected CharSequence createModelElement(final EObject grammarElement) { StringConcatenation _builder = new StringConcatenation(); _builder.append("createModelElement(grammarAccess."); String _grammarElementAccess = this._grammarAccessExtensions.grammarElementAccess(AntlrGrammarGenUtil.<ParserRule>getOriginalElement(GrammarUtil.containingParserRule(grammarElement))); _builder.append(_grammarElementAccess); _builder.append(")"); return _builder; }
/** * @since 2.0 */ protected ParserRule findRootRuleForRegion(INode node) { if (GrammarUtil.isEObjectRule(node.getGrammarElement())) return (ParserRule) node.getGrammarElement(); if (node.hasDirectSemanticElement()) return GrammarUtil.containingParserRule(node.getGrammarElement()); if (node.getParent() != null) return findRootRuleForRegion(node.getParent()); return null; }