use of org.whole.lang.grammars.model.As in project whole by wholeplatform.
the class ParserTemplateFactory method propagateActivation.
protected void propagateActivation(Set<ActiveRule> terminalSet, Set<NonTerminal> recursiveSet, ListIterator<ActiveRule> activeRules, ActiveRule ar) {
Rule dotRule = ar.getDotRule();
switch(dotRule.wGetEntityOrd()) {
case GrammarsEntityDescriptorEnum.DataTerminal_ord:
case GrammarsEntityDescriptorEnum.LiteralTerminal_ord:
terminalSet.add(ar);
break;
case GrammarsEntityDescriptorEnum.NonTerminal_ord:
NonTerminal nt = (NonTerminal) dotRule;
if (recursiveSet.add(nt)) {
activeRules.add(ar = createActiveRule(nt));
propagateActivation(terminalSet, recursiveSet, activeRules, ar);
} else
ar.setRecursive(true);
break;
case GrammarsEntityDescriptorEnum.Concatenate_ord:
Concatenate c = (Concatenate) dotRule;
if (c.wSize() > 0) {
ar.setDotRule((Rule) c.wGet(0));
propagateActivation(terminalSet, recursiveSet, activeRules, ar);
}
break;
case GrammarsEntityDescriptorEnum.Optional_ord:
Optional o = (Optional) dotRule;
ar.setDotRule(o.getRule());
propagateActivation(terminalSet, recursiveSet, activeRules, ar);
// TODO add also the rule after the optional
break;
case GrammarsEntityDescriptorEnum.Repeat_ord:
Repeat r = (Repeat) dotRule;
// TODO check lower bound and split active state for repeat continuation if 0
ar.setDotRule(r.getRule());
propagateActivation(terminalSet, recursiveSet, activeRules, ar);
break;
case GrammarsEntityDescriptorEnum.As_ord:
As as = (As) dotRule;
ar.setDotRule(as.getRule());
propagateActivation(terminalSet, recursiveSet, activeRules, ar);
break;
}
}
use of org.whole.lang.grammars.model.As in project whole by wholeplatform.
the class PathExpressionsQueriesTest method testPatternPredicate.
@Test
public void testPatternPredicate() {
ITemplateManager tm = PathExpressionsQueriesTemplateManager.instance();
Grammar g = new TestXmlGrammar().create();
int count = 0;
for (As as : BehaviorUtils.<As>compileAndLazyEvaluate((PathExpression) tm.create("path7"), g)) {
Assert.assertEquals("tag", as.getName().wStringValue());
count++;
}
Assert.assertEquals(2, count);
}
use of org.whole.lang.grammars.model.As in project whole by wholeplatform.
the class SelectQueriesTest method testSelectTemplate1.
@Test
public void testSelectTemplate1() {
ITemplateManager tm = SelectQueriesTemplateManager.instance();
Grammar model = new TestXmlGrammar().create();
IBindingManager bm = BindingManagerFactory.instance.createArguments();
PathExpression query = (PathExpression) tm.create("selectTemplate1");
for (IEntity tuple : BehaviorUtils.compileAndLazyEvaluate(query, model, bm)) {
Feature f = (Feature) tuple.wGet(0);
As e = (As) tuple.wGet(1);
assertEquals(e.getName().getValue(), f.getName().wStringValue());
assertEquals(e.getRule().wStringValue(), f.getType().wStringValue());
}
}
use of org.whole.lang.grammars.model.As in project whole by wholeplatform.
the class Grammars2ModelsVisitor method visit.
@Override
public void visit(Production entity) {
ModelsEntityFactory mf = ModelsEntityFactory.instance;
String eName = getMappedEntityName(entity);
Rule rule = entity.getRule();
AbstractPatternFilterIterator<Rule> ruleIterator = IteratorFactory.<Rule>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.Rule);
ruleIterator.reset(rule);
while (ruleIterator.hasNext()) {
rule = ruleIterator.next();
switch(rule.wGetEntityOrd()) {
// map productions with a single lexical non-terminal as data entities
case GrammarsEntityDescriptorEnum.NonTerminal_ord:
if (!isLexicalNonTerminal((NonTerminal) rule) || !EntityUtils.hasParent(rule) || !Matcher.match(GrammarsEntityDescriptorEnum.Production, rule.wGetParent()) || !Matcher.match(GrammarsEntityDescriptorEnum.DataTerminal, lexiconMap.get(((NonTerminal) rule).getValue()).getRule()))
break;
case GrammarsEntityDescriptorEnum.DataTerminal_ord:
DataEntity de = getModelDeclaration(eName, ModelsEntityDescriptorEnum.DataEntity);
Template template = entity.getTemplate();
if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.DataType, template))
de.getDataType().wSetValue(GrammarsUtils.getDataType((DataType) template));
else if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.CustomDataType, template))
de.getDataType().wSetValue(template.wStringValue());
return;
case GrammarsEntityDescriptorEnum.Choose_ord:
boolean isPolymorphic = false;
AbstractPatternFilterIterator<NonTerminal> ruleIterator2 = IteratorFactory.<NonTerminal>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.NonTerminal);
ruleIterator2.reset(rule);
for (NonTerminal nt2 : ruleIterator2) if (!isLexicalNonTerminal(nt2)) {
ensureType(getModelDeclaration(getMappedEntityName(nt2)).getTypes(), eName);
isPolymorphic = true;
}
if (isPolymorphic) {
SimpleEntity se = getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
se.getModifiers().wAdd(mf.createEntityModifier(EntityModifierEnum._abstract));
return;
} else if (!rule.wIsEmpty() && Matcher.match(GrammarsEntityDescriptorEnum.As, rule.wGet(0))) {
EnumEntity ee = getModelDeclaration(eName, ModelsEntityDescriptorEnum.EnumEntity);
EnumValues enumValues = ModelsEntityFactory.instance.createEnumValues(0);
AbstractPatternFilterIterator<As> ruleIterator3 = IteratorFactory.<As>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.As);
ruleIterator3.reset(rule);
for (As as : ruleIterator3) enumValues.wAdd(ModelsEntityFactory.instance.createEnumValue(as.getName().getValue()));
ee.setValues(enumValues);
return;
}
// }
break;
case GrammarsEntityDescriptorEnum.Repeat_ord:
if (ruleIterator.skipTo(GrammarsEntityDescriptorEnum.NonTerminal)) {
// FIXME wrongly assumes that the separator, if present, is a lexical token
if (!EntityUtils.isResolver(((Repeat) rule).getSeparator())) {
// if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.NonTerminal, ((Repeat) rule).getSeparator())) {
ruleIterator.next();
ruleIterator.skipTo(GrammarsEntityDescriptorEnum.NonTerminal);
}
NonTerminal nt = null;
AbstractPatternFilterIterator<NonTerminal> ruleIterator4 = IteratorFactory.<NonTerminal>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.NonTerminal);
ruleIterator4.reset(rule);
for (NonTerminal nt2 : ruleIterator4) if (!isLexicalNonTerminal(nt2)) {
nt = nt2;
break;
}
// by now we assume that the separator, if present, is a lexical token
if (nt == null)
break;
// the above statements replace this code, allowing lexical Repeat rule
// NonTerminal nt = ruleIterator.next(GrammarsEntityDescriptorEnum.NonTerminal);
// while (isLexicalNonTerminal(nt)) {
// nt = ruleIterator.next(GrammarsEntityDescriptorEnum.NonTerminal);
// }
CompositeEntity ce = getModelDeclaration(eName, ModelsEntityDescriptorEnum.CompositeEntity);
ce.setComponentType(mf.createSimpleName(getMappedEntityName(nt)));
ce.getComponentModifiers().wAdd(mf.createComponentModifier(ComponentModifierEnum.ordered));
}
return;
case GrammarsEntityDescriptorEnum.As_ord:
As asRule = (As) rule;
// normalization invariants assure that this branch is unreachable
// if (Matcher.match(GrammarsEntityDescriptorEnum.LiteralTerminal, asRule.getRule())) {
// EnumEntity ee = getModelDeclaration(eName, ModelsEntityDescriptorEnum.EnumEntity);
//
// ee.getValues().wAdd(mf.createEnumValue(getMappedName(asRule)));
//
// while (ruleIterator.skipTo(GrammarsEntityDescriptorEnum.As)) {
// rule = ruleIterator.next(GrammarsEntityDescriptorEnum.As);
// asRule = (As) rule;
//
// ee.getValues().wAdd(mf.createEnumValue(getMappedName(asRule)));
// }
// } else {
SimpleEntity se = getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
Features features = se.getFeatures();
ensureFeature(features, ruleIterator, asRule);
while (ruleIterator.hasNext()) {
rule = ruleIterator.next();
switch(rule.wGetEntityOrd()) {
case GrammarsEntityDescriptorEnum.As_ord:
asRule = (As) rule;
ensureFeature(features, ruleIterator, asRule);
break;
}
}
// }
return;
case GrammarsEntityDescriptorEnum.Concatenate_ord:
break;
}
}
getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
}
use of org.whole.lang.grammars.model.As in project whole by wholeplatform.
the class AsPart method getModelSpecificChildren.
protected List<IEntity> getModelSpecificChildren() {
As entity = getModelEntity();
List<IEntity> list = new ArrayList<IEntity>(2);
list.add(entity.getRule());
list.add(entity.getName());
return list;
}
Aggregations