public String getContextName(ParserRule ctx) { return ctx.getName(); }
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(); } }
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(); }
private IValueConverter<Object> getDelegate() { if (delegate != null) return delegate; return delegate = service.getConverter(grammarAccess.getValidIDRule().getName()); }
@Override public IParseResult parse(ParserRule rule, Reader reader) { IParseResult parseResult = parse(rule.getName(), new ReaderCharStream(reader)); return parseResult; }
public String getContextName(Action ctx) { ParserRule rule = EcoreUtil2.getContainerOfType(ctx, ParserRule.class); return rule.getName() + "_" + getUniqueActionName(ctx); }
@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); }
public String getMessage() { StringBuffer msg = new StringBuffer(); msg.append("The feature "); msg.append(feature.getEContainingClass().getName()); if (feature.getEContainingClass() != source.eClass()) { msg.append("("); msg.append(source.eClass().getName()); msg.append(")"); } msg.append("."); msg.append(feature.getName()); switch (getCode()) { case ERROR_ASSIGNMENT_MISSING: msg.append(" contains non-transient values but has no corresponding assignment in rule "); msg.append(getRule().getName()); break; case ERROR_ASSIGNMENT_PROHIBITED: msg.append(" is not allowed to contain non-transient values. "); msg.append("The object needs to be of type "); msg.append(Joiner.on(" or ").join(Iterables.transform(requiredTypes, new Function<EClass, String>() { public String apply(EClass from) { return from.getName(); } }))); } msg.append("."); appendConstraint(msg); return msg.toString(); } }
public IParseResult parse(ParserRule rule, Reader reader) { try { IParseResult parseResult = parse(rule.getName(), new ANTLRReaderStream(reader)); return parseResult; } catch (IOException e) { throw new WrappedException(e); } }
@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; }
@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); }
public String getSignificantGrammarElement(final Iterable<ISerializationContext> contexts) { ParserRule rule = null; int index = Integer.MAX_VALUE; for (final ISerializationContext ctx : contexts) { { ParserRule pr = ctx.getParserRule(); if ((pr == null)) { final Action action = ctx.getAssignedAction(); if ((action != null)) { pr = GrammarUtil.containingParserRule(action); } } if ((pr != null)) { final Integer i = this.rules.get(pr); if (((i).intValue() < index)) { index = (i).intValue(); rule = pr; } } } } if ((rule != null)) { return rule.getName(); } return "unknown"; } }
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(); }
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.4 * @nooverride This method is not intended to be re-implemented or extended by clients. * @noreference This method is not intended to be referenced by clients. */ protected void registerEFactoryConverters(Map<String, IValueConverter<Object>> converters) { for (ParserRule parserRule : allParserRules(getGrammar())) { if (isDatatypeRule(parserRule) && !converters.containsKey(parserRule.getName())) { EDataType datatype = (EDataType) parserRule.getType().getClassifier(); converters.put(parserRule.getName(), new EFactoryValueConverter(datatype)); } } for (TerminalRule terminalRule : allTerminalRules(getGrammar())) { if (!terminalRule.isFragment()) { String terminalRuleName = terminalRule.getName(); if (!converters.containsKey(terminalRuleName)) { converters.put(terminalRuleName, defaultTerminalConverterFactory.create(terminalRule)); } } } }
protected void registerContextTypes(IGrammarAccess grammarAccess, Provider<XtextTemplateContextType> ctxTypeProvider) { List<ParserRule> parserRules = GrammarUtil.allParserRules(grammarAccess.getGrammar()); List<XtextTemplateContextType> allContextTypes = Lists.newArrayList(); for (ParserRule parserRule : parserRules) { XtextTemplateContextType type = ctxTypeProvider.get(); type.setName(parserRule.getName()); type.setId(getId(parserRule)); allContextTypes.add(type); List<Keyword> keywords = EcoreUtil2.getAllContentsOfType(parserRule, Keyword.class); for (Keyword keyword : keywords) { String value = getId(keyword); if (value!=null) { type = ctxTypeProvider.get(); type.setName("Keyword '"+keyword.getValue()+"'"); type.setId(value); allContextTypes.add(type); } } } Collections.sort(allContextTypes); for (XtextTemplateContextType templateContextType: allContextTypes) { addContextType(templateContextType); } }
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 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); }
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; }
_builder.append(" \t"); _builder.append("return \""); String _name = AntlrGrammarGenUtil.<ParserRule>getOriginalElement(IterableExtensions.<ParserRule>head(GrammarUtil.allParserRules(it))).getName(); _builder.append(_name, " \t"); _builder.append("\";");