org.eclipse.xtext.ParserRule Java Examples

@Test
public void testBug306281_10() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar org.foo with org.eclipse.xtext.common.Terminals");
  _builder.newLine();
  _builder.append("generate metamodel \'foo.sample\'");
  _builder.newLine();
  _builder.append("Model : name=ID (({Binary.left=current} operator = [Model] | {Binary.left=current} operator = [Model]) name=ID);");
  _builder.newLine();
  String grammarAsString = _builder.toString();
  final Grammar grammar = this.getGrammar(grammarAsString);
  AbstractRule _findRuleForName = GrammarUtil.findRuleForName(grammar, "Model");
  final ParserRule rule = ((ParserRule) _findRuleForName);
  this.validateRule(rule);
  Assert.assertTrue(this.warnings.toString(), this.warnings.isEmpty());
}
 

@Test
public void test1() throws Exception {
	with(ReferenceGrammarTestLanguageStandaloneSetup.class);
	String model = "kind (Hugo 13)";
	ParserRule kindRule = get(ReferenceGrammarTestLanguageGrammarAccess.class).getKindRule();
	XtextResource resource = createResource();
	// test 1: parse and assume there are no errors
	resource.setEntryPoint(kindRule);
	resource.load(new StringInputStream(model), Collections.emptyMap());
	Assert.assertTrue(resource.getErrors().isEmpty());
	Assert.assertEquals(kindRule, NodeModelUtils.getEntryParserRule(resource.getParseResult().getRootNode()));
	// test 2: update and assume node model does not change
	String originalNodeModel = NodeModelUtils.compactDump(resource.getParseResult().getRootNode(), false);
	resource.update(0, model.length(), " " + model + " ");
	String reparsedNodeModel = NodeModelUtils.compactDump(resource.getParseResult().getRootNode(), false);
	Assert.assertEquals(originalNodeModel, reparsedNodeModel);
	// test 3: change parser rule
	ParserRule erwachsenerRule = get(ReferenceGrammarTestLanguageGrammarAccess.class).getErwachsenerRule();
	resource.setEntryPoint(erwachsenerRule);
	resource.update(0, model.length(), "erwachsener (Peter 30)");
	Assert.assertEquals(erwachsenerRule,
			NodeModelUtils.getEntryParserRule(resource.getParseResult().getRootNode()));
}
 

public static ParserRule getEntryParserRule(INode node) {
	ICompositeNode root = node.getRootNode();
	EObject ge1 = root.getGrammarElement();
	if (ge1 instanceof ParserRule) {
		return (ParserRule) ge1;
	} else if (ge1 instanceof Action) {
		INode firstChild = root.getFirstChild();
		while (firstChild.getGrammarElement() instanceof Action && firstChild instanceof CompositeNode) {
			firstChild = ((CompositeNode)firstChild).getFirstChild();
		}
		EObject ge2 = firstChild.getGrammarElement();
		if (ge2 instanceof ParserRule) {
			return (ParserRule) ge2;
		}
	}
	throw new IllegalStateException("No Root Parser Rule found; The Node Model is broken.");
}
 

@Test public void testAssignment_02() throws Exception {
	String grammarAsString = "grammar org.foo with org.eclipse.xtext.common.Terminals\n" +
			"generate metamodel 'foo.sample'\n" +
			"Model: x=X;\n" +
			"X : (x+='x')+;";
	Grammar grammar = getGrammar(grammarAsString);
	ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(grammar, "X");
	validateRule(rule);
	assertTrue(warnings.toString(), warnings.isEmpty());
}
 

private String parseRule(String body) throws Exception {
	Grammar grammar = (Grammar) getModel(HEADER + body);
	Matcher m = Pattern.compile("^[a-zA-Z]+").matcher(body);
	m.find();
	String firstRuleName = m.group();
	AbstractRule firstRule = GrammarUtil.findRuleForName(grammar, firstRuleName);
	IConcreteSyntaxConstraintProvider cscp = new CSCPTest(grammar);
	return toString(cscp.getConstraint((ParserRule) firstRule));
}
 

@Override
protected boolean canInspect(ParserRule rule) {
	if (GrammarUtil.getGrammar(rule).getRules().get(0) != rule)
		return false;
	if (GrammarUtil.isDatatypeRule(rule) || rule.getAlternatives() == null)
		return false;
	return super.canInspect(rule);
}
 

@Test public void testGetStyledTextFallbackText() throws Exception {
	DefaultEObjectLabelProvider defaultLabelProvider = new DefaultEObjectLabelProvider();
	ParserRule parserRule = XtextFactory.eINSTANCE.createParserRule();
	parserRule.setName("testCreateStyledString");
	StyledString styledText = defaultLabelProvider.getStyledText(parserRule);
	assertEquals("testCreateStyledString", styledText.getString());
}
 

@Test public void testRuleModelId() {
	AbstractRule rule = grammar.getRules().get(2);
	assertEquals("ModelId", rule.getName());
	ParserRule parserRule = (ParserRule) rule;
	assertTrue(GrammarUtil.isDatatypeRule(parserRule));
	assertNotNull(rule.getType());
	assertNotNull(rule.getType().getClassifier());
	assertEquals(EcorePackage.Literals.ESTRING, rule.getType().getClassifier());
}
 

protected CharSequence compileRestoreHiddenTokens(final AbstractRule it, final AntlrOptions options) {
  if (it instanceof ParserRule) {
    return _compileRestoreHiddenTokens((ParserRule)it, options);
  } else if (it != null) {
    return _compileRestoreHiddenTokens(it, options);
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(it, options).toString());
  }
}
 

@Test public void testCheckRuleCallInUnorderedGroup_02() throws Exception {
	XtextValidator validator = get(XtextValidator.class);
	UnorderedGroup unorderedGroup = XtextFactory.eINSTANCE.createUnorderedGroup();
	RuleCall ruleCall = XtextFactory.eINSTANCE.createRuleCall();
	TypeRef typeRef = XtextFactory.eINSTANCE.createTypeRef();
	typeRef.setClassifier(EcorePackage.Literals.EBIG_DECIMAL);
	ParserRule parserRule = XtextFactory.eINSTANCE.createParserRule();
	parserRule.setType(typeRef);
	ruleCall.setRule(parserRule);
	unorderedGroup.getElements().add(ruleCall);
	ValidatingMessageAcceptor messageAcceptor = new ValidatingMessageAcceptor(null, false, false);
	validator.setMessageAcceptor(messageAcceptor);
	validator.checkRuleCallInUnorderedGroup(ruleCall);
	messageAcceptor.validate();
}
 

@Override
protected String crossrefEbnf(final AbstractRule it, final RuleCall call, final CrossReference ref, final boolean supportActions) {
  String _xifexpression = null;
  if (supportActions) {
    String _switchResult = null;
    boolean _matched = false;
    if (it instanceof EnumRule) {
      _matched=true;
    }
    if (!_matched) {
      if (it instanceof ParserRule) {
        _matched=true;
      }
    }
    if (_matched) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("{");
      _builder.newLine();
      _builder.append("\t");
      CharSequence _newCompositeNode = this.newCompositeNode(ref);
      _builder.append(_newCompositeNode, "\t");
      _builder.newLineIfNotEmpty();
      _builder.append("}");
      _builder.newLine();
      String _ruleName = this._grammarAccessExtensions.ruleName(it);
      _builder.append(_ruleName);
      String _argumentList = AntlrGrammarGenUtil.getArgumentList(call, this.isPassCurrentIntoFragment(), (!supportActions));
      _builder.append(_argumentList);
      _builder.newLineIfNotEmpty();
      _builder.append("{");
      _builder.newLine();
      _builder.append("\t");
      _builder.append("afterParserOrEnumRuleCall();");
      _builder.newLine();
      _builder.append("}");
      _builder.newLine();
      _switchResult = _builder.toString();
    }
    if (!_matched) {
      if (it instanceof TerminalRule) {
        _matched=true;
        StringConcatenation _builder_1 = new StringConcatenation();
        String _localVar = this._grammarAccessExtensions.localVar(GrammarUtil.containingAssignment(ref));
        _builder_1.append(_localVar);
        _builder_1.append("=");
        String _ruleName_1 = this._grammarAccessExtensions.ruleName(it);
        _builder_1.append(_ruleName_1);
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("{");
        _builder_1.newLine();
        _builder_1.append("\t");
        CharSequence _newLeafNode = this.newLeafNode(ref, this._grammarAccessExtensions.localVar(GrammarUtil.containingAssignment(ref)));
        _builder_1.append(_newLeafNode, "\t");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("}");
        _builder_1.newLine();
        _switchResult = _builder_1.toString();
      }
    }
    if (!_matched) {
      throw new IllegalStateException(("crossrefEbnf is not supported for " + it));
    }
    _xifexpression = _switchResult;
  } else {
    _xifexpression = super.crossrefEbnf(it, call, ref, supportActions);
  }
  return _xifexpression;
}
 

public ParserRule getMyClassRule() {
	return getMyClassAccess().getRule();
}
 

public ParserRule getDatatypeRuleRule() {
	return getDatatypeRuleAccess().getRule();
}
 

public ParserRule getScenario8Rule() {
	return getScenario8Access().getRule();
}
 

public ParserRule getDataTypeRule() {
	return getDataTypeAccess().getRule();
}
 

public ParserRule getQualifiedNameRule() {
	return getQualifiedNameAccess().getRule();
}
 

public ParserRule getScenario2Rule() {
	return getScenario2Access().getRule();
}
 

public ParserRule getXAnnotationRule() {
	return getXAnnotationAccess().getRule();
}
 

public ParserRule getTreeNodeRule() {
	return getTreeNodeAccess().getRule();
}
 

public ParserRule getEscapedCharacterClassAtomRule() {
	return getEscapedCharacterClassAtomAccess().getRule();
}
 

public ParserRule getXCastedExpressionRule() {
	return getXCastedExpressionAccess().getRule();
}
 

public ParserRule getListExpressionRule() {
	return getListExpressionAccess().getRule();
}
 

public ParserRule getRootRule() {
	return getRootAccess().getRule();
}
 

public ParserRule getError_1Rule() {
	return getError_1Access().getRule();
}
 

public ParserRule getIndentRule() {
	return getIndentAccess().getRule();
}
 

public ParserRule getJvmLowerBoundRule() {
	return getJvmLowerBoundAccess().getRule();
}
 

public ParserRule getModelRule() {
	return getModelAccess().getRule();
}
 

public ParserRule getReducibleRuleRule() {
	return getReducibleRuleAccess().getRule();
}
 

public ParserRule getINT0Rule() {
	return getINT0Access().getRule();
}
 

public ParserRule getOpOrRule() {
	return getOpOrAccess().getRule();
}