/** * @since 2.0 */ public static boolean isEObjectRule(EObject grammarElement) { return grammarElement instanceof ParserRule && ((ParserRule) grammarElement).getType().getClassifier() instanceof EClass; }
@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; }
protected List<EObject> calculateSortingRule(ParserRule grammarElement) { final List<EObject> sortingRule = Lists.newArrayList(grammarElement.eAllContents()); // for each RuleCall add a corresponding ParserRule for (EObject next : Lists.newArrayList(sortingRule)) { if (next instanceof RuleCall) { AbstractRule rule = ((RuleCall) next).getRule(); sortingRule.add(sortingRule.indexOf(next) + 1, rule); } } return Collections.unmodifiableList(sortingRule); }
@Override public AbstractRule getWhitespaceRuleFor(ParserRule context, String whitespace) { if (context == null || !context.isDefinesHiddenTokens()) return wsRule; if (context.getHiddenTokens().contains(wsRule)) return wsRule; return null; }
@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 void handleResult(Boolean r, ParserRule rule) { if (!r.booleanValue()) acceptWarning( "The rule '" + rule.getName() + "' may be consumed without object instantiation. " + "Add an action to ensure object creation, e.g. '{" + getTypeRefName(rule.getType()) + "}'." , rule, XtextPackage.Literals.ABSTRACT_RULE__NAME); }
@Override public AbstractElement getRoot() { return context.getAlternatives(); } }
public String getContextName(ParserRule ctx) { return ctx.getName(); }
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()); }
_builder.newLineIfNotEmpty(); boolean _isDefinesHiddenTokens = it.isDefinesHiddenTokens(); if (_isDefinesHiddenTokens) { _builder.append("@init { "); _builder.newLine(); boolean _isDefinesHiddenTokens_1 = it.isDefinesHiddenTokens(); if (_isDefinesHiddenTokens_1) { _builder.append("finally {"); String _name = AntlrGrammarGenUtil.<ParserRule>getOriginalElement(it).getName(); _builder.append(_name); _builder.newLineIfNotEmpty(); _builder.newLine(); _builder.append("\t"); String _ebnf = this.ebnf(it.getAlternatives(), options, false); _builder.append(_ebnf, "\t"); _builder.newLineIfNotEmpty();
public boolean apply(RuleCall input) { return ((ParserRule) input.getRule()).isDefinesHiddenTokens(); } });
@Override protected void handleResult(Pair<Boolean, Boolean> r, ParserRule rule) { if (!r.getFirst().booleanValue()) acceptWarning( "The entry rule '" + rule.getName() + "' may consume non empty input without object instantiation. " + "Add an action to ensure object creation, e.g. '{" + getTypeRefName(rule.getType()) + "}'." , rule, XtextPackage.Literals.ABSTRACT_RULE__NAME); }
@Override public Boolean caseParserRule(ParserRule object) { if (object.getAlternatives() != null) return doSwitch(object.getAlternatives()); return true; }
public String getMessage() { StringBuffer msg = new StringBuffer(); msg.append("A feature named '"); msg.append(element.getAssignmentName()); msg.append("' in "); msg.append(source.eClass().getName()); msg.append(" is needed for serialization with rule "); msg.append(getRule().getName()); msg.append("."); appendConstraint(msg); return msg.toString(); } }
@Check public void checkHiddenTokenIsNotAFragment(ParserRule rule) { if (rule.isDefinesHiddenTokens()) { checkHiddenTokenIsNotAFragment(rule, rule.getHiddenTokens(), XtextPackage.Literals.PARSER_RULE__HIDDEN_TOKENS); } }
protected CharSequence _compileRestoreHiddenTokens(final ParserRule it, final AntlrOptions options) { StringConcatenation _builder = new StringConcatenation(); { boolean _isDefinesHiddenTokens = it.isDefinesHiddenTokens(); if (_isDefinesHiddenTokens) { _builder.append("myHiddenTokenState.restore();"); } } return _builder; }
@Override public IEObjectConsumer tryConsume() { if(getEObject().eClass() != grammarAccess.getCrossReferenceRule().getType().getClassifier()) return null; return eObjectConsumer; }
private boolean deriveTypeHierarchyFromOverridden(ParserRule rule, Grammar grammar) throws TransformationException { AbstractRule parentRule = GrammarUtil.findRuleForName(grammar, rule.getName()); if (parentRule != null && parentRule.getType() != null && parentRule != rule) { if (parentRule.getType().getClassifier() instanceof EDataType) throw new TransformationException(TransformationErrorCode.InvalidSupertype, "Cannot inherit from datatype rule and return another type.", rule.getType()); EClassifierInfo parentTypeInfo = eClassifierInfos.getInfoOrNull(parentRule.getType()); if (parentTypeInfo == null) throw new TransformationException(TransformationErrorCode.InvalidSupertype, "Cannot determine return type of overridden rule.", rule.getType()); addSuperType(rule, rule.getType(), parentTypeInfo); return true; } return false; }
@Override public Boolean caseParserRule(ParserRule object) { return object == child || (rules.add(object) && doSwitch(object.getAlternatives())); } }.doSwitch(parent);
public String getMessage() { StringBuffer msg = new StringBuffer(); msg.append("An object of type "); msg.append(Joiner.on(" or ").join(Iterables.transform(getSemanticTypes(), new Function<EClass, String>() { public String apply(EClass from) { return from.getName(); } }))); msg.append(" is needed instead of "); msg.append(source.eClass().getName()); msg.append(" for serialization with rule "); msg.append(getRule().getName()); msg.append("."); appendConstraint(msg); return msg.toString(); }