@Inject protected void setGrammar(IGrammarAccess grammar) { this.grammar = grammar.getGrammar(); } }
@Inject public void setGrammar(IGrammarAccess grammarAccess) { this.grammar = grammarAccess.getGrammar(); }
protected Set<String> getValuesToEscape() { if (valuesToEscape == null) valuesToEscape = computeValuesToEscape(grammarAccess.getGrammar()); return valuesToEscape; }
private AbstractRule getTemplateRule() { if (templateRule == null) templateRule = GrammarUtil.findRuleForName(grammarAccess.getGrammar(), "Codetemplate"); return templateRule; }
private AbstractRule getTemplatesRule() { if (templatesRule == null) templatesRule = GrammarUtil.findRuleForName(grammarAccess.getGrammar(), "Codetemplates"); return templatesRule; }
protected TerminalRule getWSRule() { // FIXME: make this configurable return (TerminalRule) GrammarUtil.findRuleForName(grammar.getGrammar(), "WS"); }
@Inject private void setGrammar(IGrammarAccess grammar) { wsRule = GrammarUtil.findRuleForName(grammar.getGrammar(), "WS"); }
protected List<EObject> findPathToImportSection() { EList<AbstractRule> rules = grammarAccess.getGrammar().getRules(); if(!rules.isEmpty() && rules.get(0) instanceof ParserRule) { LinkedList<EObject> pathToImportSection = newLinkedList(); if(internalFindPathToImportSection(pathToImportSection, new HashSet<ParserRule>(), rules.get(0))) { return pathToImportSection; } } return null; }
@Override protected List<EPackage> getEPackages() { List<EPackage> pkg = new ArrayList<EPackage>(); for (AbstractMetamodelDeclaration a : GrammarUtil.allMetamodelDeclarations(grammar.getGrammar())) pkg.add(a.getEPackage()); return pkg; }
protected int getElementID(AbstractElement ele) { if (elementIDCache == null) { elementIDCache = Maps.newHashMap(); int counter = 0; for (ParserRule pr : GrammarUtil.allParserRules(grammar.getGrammar())) for (AbstractElement e : EcoreUtil2.getAllContentsOfType(pr, AbstractElement.class)) elementIDCache.put(e, counter++); } return elementIDCache.get(ele); }
@Inject public void register(LanguageAcceptor acceptor) { acceptor.accept(grammarAccess.getGrammar(), highlighter, contextTypeRegistry, helper, contentAssistContextFactory, fileExtensionProvider.getFileExtensions().iterator().next()); }
protected EObject getRootContext() { for (AbstractRule rule : grammar.getGrammar().getRules()) if (GrammarUtil.isEObjectRule(rule)) return rule; throw new RuntimeException("There is no parser rule in the grammar."); }
protected List<EClass> getValidTypes(EObject context) { List<IConstraintContext> constraints = grammarConstraints.getConstraints(grammarAccess.getGrammar()); for (IConstraintContext ctx : constraints) if (ctx.getContext() == context) { List<EClass> result = Lists.newArrayList(); for (IConstraint c : ctx.getConstraints()) result.add(c.getType()); return result; } return Collections.emptyList(); }
@Override @SuppressWarnings({ "unchecked" }) protected Props drawObject(Object obj) { if (obj == null) throw new NullPointerException("Obj null"); if (obj instanceof TransitionMatcher) { TransitionMatcher<IElementMatcherProvider.IElementPattern> m = (TransitionMatcher<IElementMatcherProvider.IElementPattern>) obj; nfaProvider = m.nfaProvider; return super.drawObject(m.getGrammar().getGrammar()); } return super.drawObject(obj); }
protected List<EObject> getValidContexts(EClass clazz) { List<EObject> result = Lists.newArrayList(); List<IConstraintContext> constraints = grammarConstraints.getConstraints(grammarAccess.getGrammar()); for (IConstraintContext ctx : constraints) for (IConstraint c : ctx.getConstraints()) if (c.getType() == clazz) result.add(ctx.getContext()); return result; }
protected void initConstraints() { if (constraintContexts == null) { constraints = Maps.newHashMap(); constraintContexts = grammarConstraintProvider.getConstraints(grammarAccess.getGrammar()); // System.out.println(Joiner.on("\n").join(constraintContexts)); for (IConstraintContext ctx : constraintContexts) for (IConstraint constraint : ctx.getConstraints()) constraints.put(Tuples.create(ctx.getContext(), constraint.getType()), constraint); } }
protected void initConstraints() { if (constraintContexts == null) { constraints = Maps.newHashMap(); constraintContexts = grammarConstraintProvider.getConstraints(grammar.getGrammar()); // System.out.println(Joiner.on("\n").join(constraintContexts)); for (IConstraintContext ctx : constraintContexts) for (IConstraint constraint : ctx.getConstraints()) constraints.put(Tuples.create(ctx.getContext(), constraint.getType()), constraint); } }
public Iterable<String> getKeywords() { final Function1<Keyword, Boolean> _function = (Keyword it) -> { return Boolean.valueOf(Character.isLetter(it.getValue().charAt(0))); }; final Function1<Keyword, String> _function_1 = (Keyword it) -> { return it.getValue(); }; return IterableExtensions.<String>sort(IterableExtensions.<String>toSet(IterableExtensions.<Keyword, String>map(IterableExtensions.<Keyword>filter(GrammarUtil.containedKeywords(this.grammarAccess.getGrammar()), _function), _function_1))); } }
protected Grammar getGrammar(XtextTemplateContext xtextTemplateContext) { EObject grammarElement = xtextTemplateContext.getContentAssistContext() .getRootNode().getGrammarElement(); if (grammarElement == null && grammarAccess != null) return grammarAccess.getGrammar(); return (Grammar) EcoreUtil.getRootContainer(grammarElement); }
@Inject protected void register(final EValidatorRegistrar registrar, final IGrammarAccess grammarAccess) { final AbstractRule entryRule = IterableExtensions.<AbstractRule>head(grammarAccess.getGrammar().getRules()); if ((entryRule instanceof ParserRule)) { registrar.register(((ParserRule)entryRule).getType().getClassifier().getEPackage(), this); } }