/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public NumericExprT(MasterGrammar p) : base(p)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var numericExprT = new NonTerminal("Timed numeric expression", typeof(TransientAstNode));
var numericExprTSimple = new NonTerminal("Simple timed numeric expression", typeof(TimedNumericExpressionAstNode));
var numericExprTComplex = new NonTerminal("Product of timed numeric expression", typeof(TransientAstNode));
var numericExprTProduct = new NonTerminal("Product variant of timed numeric expression", typeof(TimedNumericExpressionAstNode));
var numericExprTProductVariant = new NonTerminal("Either product variant of timed numeric expression", typeof(TransientAstNode));
var numericExprTProductVariant1 = new NonTerminal("Product variant 1 of timed numeric expression", typeof(TransientAstNode));
var numericExprTProductVariant2 = new NonTerminal("Product variant 2 of timed numeric expression", typeof(TransientAstNode));
// USED SUB-TREES
var numericExpr = new NumericExpr(p);
// RULES
numericExprT.Rule = numericExprTSimple | numericExprTComplex;
numericExprTSimple.Rule = p.ToTerm("#t");
numericExprTComplex.Rule = p.ToTerm("(") + numericExprTProduct + ")";
numericExprTProduct.Rule = p.ToTerm("*") + numericExprTProductVariant;
numericExprTProductVariant.Rule = numericExprTProductVariant1 | numericExprTProductVariant2;
numericExprTProductVariant1.Rule = p.ToTerm("#t") + numericExpr;
numericExprTProductVariant2.Rule = numericExpr + "#t";
p.MarkTransient(numericExprT, numericExprTComplex, numericExprTProductVariant);
Rule = numericExprT;
}
/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public PreGd(MasterGrammar p) : base(p)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var preGd = new NonTerminal("Pre-GD", typeof(TransientAstNode));
var preGdBase = new NonTerminal("Pre-GD base", typeof(TransientAstNode));
var preGdStarList = new NonTerminal("Pre-GD star-list", typeof(TransientAstNode));
var prefPreGdBase = new NonTerminal("Preference expression (pre-GD)", typeof(PreferenceGdAstNode));
var prefNameOrEmpty = new NonTerminal("Optional preference name", typeof(TransientAstNode));
var prefName = new IdentifierTerminal("Preference name", IdentifierType.CONSTANT);
var andPreGdBase = new NonTerminal("AND expression (pre-GDs)", typeof(AndGdAstNode));
var forallPreGdBase = new NonTerminal("FORALL expression (pre-GD)", typeof(ForallGdAstNode));
var orGdBase = new NonTerminal("OR expression (pre-GD)", typeof(OrGdAstNode));
var notGdBase = new NonTerminal("NOT expression (pre-GD)", typeof(NotGdAstNode));
var implyGdBase = new NonTerminal("IMPLY expression (pre-GD)", typeof(ImplyGdAstNode));
var existsGdBase = new NonTerminal("EXISTS expression (pre-GD)", typeof(ExistsGdAstNode));
var equalsOpGdBase = new NonTerminal("Equals operator (pre-GD)", typeof(EqualsOpGdAstNode));
var numCompGdBase = new NonTerminal("Numeric comparison expression (pre-GD)", typeof(NumCompGdAstNode));
var binaryComparer = new NonTerminal("Binary comparer", typeof(TransientAstNode));
var gdStarList = new NonTerminal("GD star-list", typeof(TransientAstNode));
// USED SUB-TREES
var typedList = new TypedList(p);
var gd = new Gd(p);
var predicateGdBase = new PredicateGd(p, BForm.BASE);
var numericExpr = new NumericExpr(p);
var valueOrTerm = new ValueOrTerm(p);
// RULES
preGd.Rule = p.ToTerm("(") + preGdBase + ")";
preGdBase.Rule = prefPreGdBase | andPreGdBase | forallPreGdBase | orGdBase | notGdBase | implyGdBase | existsGdBase | predicateGdBase | equalsOpGdBase | numCompGdBase;
prefPreGdBase.Rule = p.ToTerm("preference") + prefNameOrEmpty + gd;
prefNameOrEmpty.Rule = prefName | p.Empty;
andPreGdBase.Rule = p.ToTerm("and") + preGdStarList;
forallPreGdBase.Rule = p.ToTerm("forall") + "(" + typedList + ")" + preGd;
orGdBase.Rule = p.ToTerm("or") + gdStarList;
notGdBase.Rule = p.ToTerm("not") + gd;
implyGdBase.Rule = p.ToTerm("imply") + gd + gd;
existsGdBase.Rule = p.ToTerm("exists") + "(" + typedList + ")" + gd;
equalsOpGdBase.Rule = p.ToTerm("=") + valueOrTerm + valueOrTerm;
numCompGdBase.Rule = binaryComparer + numericExpr + numericExpr;
binaryComparer.Rule = p.ToTerm(">") | "<" | ">=" | "<=";
preGdStarList.Rule = p.MakeStarRule(preGdStarList, preGd);
gdStarList.Rule = p.MakeStarRule(gdStarList, gd);
p.MarkTransient(preGd, preGdBase, gd, numericExpr, binaryComparer);
Rule = preGd;
}
/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public NumericExprDa(MasterGrammar p) : base(p)
{
var durationVar = new NonTerminal("Duration variable term (duration numeric expression)", typeof(DurationVariableTermAstNode))
{
Rule = p.ToTerm("?duration")
};
Rule = NumericExpr.ConstructNumericExprRule(p, durationVar);
}
/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public DurConstr(MasterGrammar p) : base(p)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var durationConstr = new NonTerminal("Duration-constraint", typeof(TransientAstNode));
var durationConstrBase = new NonTerminal("Duration-constraint base", typeof(TransientAstNode));
var simpleDurationConstr = new NonTerminal("Simple duration-constraint", typeof(TransientAstNode));
var simpleDurationConstrBase = new NonTerminal("Simple duration-constraint base", typeof(TransientAstNode));
var andSimpleDurationConstrsBase = new NonTerminal("AND expression (duration-constraints)", typeof(AndSimpleDurationConstraintsAstNode));
var simpleDurationConstrsPlusList = new NonTerminal("Simple duration constraints plus-list", typeof(TransientAstNode));
var atSimpleDurationConstr = new NonTerminal("AT expression (duration-constraint)", typeof(AtSimpleDurationConstraintAstNode));
var compOpSimpleDurationConstr = new NonTerminal("CompareOp (duration-constraint)", typeof(CompOpSimpleDurationConstraintAstNode));
var timeSpecifier = new NonTerminal("Time specifier", typeof(TransientAstNode));
var durCompareOp = new NonTerminal("Compare operator for duration-constraint", typeof(TransientAstNode));
var durCompareVal = new NonTerminal("Value for duration-constraint", typeof(TransientAstNode));
// USED SUB-TREES
var numericExpr = new NumericExpr(p);
// RULES
durationConstr.Rule = p.ToTerm("(") + durationConstrBase + ")";
durationConstrBase.Rule = andSimpleDurationConstrsBase | simpleDurationConstrBase;
andSimpleDurationConstrsBase.Rule = p.ToTerm("and") + simpleDurationConstrsPlusList;
simpleDurationConstrsPlusList.Rule = p.MakeStarRule(simpleDurationConstrsPlusList, simpleDurationConstr);
simpleDurationConstr.Rule = p.ToTerm("(") + simpleDurationConstrBase + ")";
simpleDurationConstrBase.Rule = atSimpleDurationConstr | compOpSimpleDurationConstr;
atSimpleDurationConstr.Rule = p.ToTerm("at") + timeSpecifier + simpleDurationConstr;
compOpSimpleDurationConstr.Rule = durCompareOp + "?duration" + durCompareVal;
timeSpecifier.Rule = p.ToTerm("start") | p.ToTerm("end");
durCompareOp.Rule = p.ToTerm("<=") | ">=" | "=";
durCompareVal.Rule = numericExpr;
p.MarkTransient(durationConstr, durationConstrBase, simpleDurationConstr, simpleDurationConstrBase, durCompareVal);
Rule = durationConstr;
}
/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public Gd(MasterGrammar p) : base(p)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var gd = new NonTerminal("GD", typeof(TransientAstNode));
var gdBase = new NonTerminal("GD base", typeof(TransientAstNode));
var gdStarList = new NonTerminal("GD star-list", typeof(TransientAstNode));
var andGdBase = new NonTerminal("AND expression (GDs)", typeof(AndGdAstNode));
var orGdBase = new NonTerminal("OR expression (GD)", typeof(OrGdAstNode));
var notGdBase = new NonTerminal("NOT expression (GD)", typeof(NotGdAstNode));
var implyGdBase = new NonTerminal("IMPLY expression (GD)", typeof(ImplyGdAstNode));
var existsGdBase = new NonTerminal("EXISTS expression (GD)", typeof(ExistsGdAstNode));
var forallGdBase = new NonTerminal("FORALL expression (GD)", typeof(ForallGdAstNode));
var equalsOpGdBase = new NonTerminal("Equals operator (GD)", typeof(EqualsOpGdAstNode));
var numCompGdBase = new NonTerminal("Numeric comparison expression (GD)", typeof(NumCompGdAstNode));
var binaryComparer = new NonTerminal("Binary comparer", typeof(TransientAstNode));
// USED SUB-TREES
var typedList = new TypedList(p);
var numericExpr = new NumericExpr(p);
var valueOrTerm = new ValueOrTerm(p);
var predicateGdBase = new PredicateGd(p, BForm.BASE);
// RULES
gd.Rule = p.ToTerm("(") + gdBase + ")";
gdBase.Rule = andGdBase | orGdBase | notGdBase | implyGdBase | existsGdBase | forallGdBase | predicateGdBase | equalsOpGdBase | numCompGdBase;
andGdBase.Rule = p.ToTerm("and") + gdStarList;
orGdBase.Rule = p.ToTerm("or") + gdStarList;
notGdBase.Rule = p.ToTerm("not") + gd;
implyGdBase.Rule = p.ToTerm("imply") + gd + gd;
existsGdBase.Rule = p.ToTerm("exists") + "(" + typedList + ")" + gd;
forallGdBase.Rule = p.ToTerm("forall") + "(" + typedList + ")" + gd;
equalsOpGdBase.Rule = p.ToTerm("=") + valueOrTerm + valueOrTerm;
numCompGdBase.Rule = binaryComparer + numericExpr + numericExpr;
binaryComparer.Rule = p.ToTerm(">") | "<" | ">=" | "<=";
gdStarList.Rule = p.MakeStarRule(gdStarList, gd);
p.MarkTransient(gd, gdBase, binaryComparer);
Rule = gd;
}