/// <summary>
/// Constructs the numeric expression rule from the specified parameters.
/// </summary>
/// <param name="p">Parent master grammar.</param>
/// <param name="durationVariable">Duration variable.</param>
/// <returns>Numeric expression grammar rule.</returns>
public static NonTerminal ConstructNumericExprRule(MasterGrammar p, NonTerminal durationVariable = null)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var numericExpr = new NonTerminal("Numeric expression", typeof(TransientAstNode));
var numericExprNumber = new NonTerminal("Number term for numeric expression", typeof(NumberTermAstNode));
var numericExprFuncIdentifier = new NonTerminal("Function identifier term for numeric expression", typeof(FunctionTermAstNode));
var numericExprComplex = new NonTerminal("Complex numeric expression", typeof(TransientAstNode));
var numericExprComplexBase = new NonTerminal("Complex numeric expression base", typeof(TransientAstNode));
var number = new NumberLiteral("Number");
var functionIdentifier = new IdentifierTerminal("Function identifier", IdentifierType.CONSTANT);
// USED SUB-TREES
var termFunctionBase = new FunctionTerm(p, BForm.BASE);
var numericOpBase = new NumericOp(p, numericExpr, BForm.BASE);
// RULES
numericExpr.Rule = numericExprNumber | numericExprFuncIdentifier | numericExprComplex;
numericExprNumber.Rule = number;
numericExprFuncIdentifier.Rule = functionIdentifier;
numericExprComplex.Rule = p.ToTerm("(") + numericExprComplexBase + ")";
numericExprComplexBase.Rule = termFunctionBase | numericOpBase;
if (durationVariable != null)
{
numericExpr.Rule = durationVariable | numericExpr.Rule;
}
p.MarkTransient(numericExpr, numericExprComplex, numericExprComplexBase, numericOpBase);
return(numericExpr);
}
/// <summary>
/// Constructor of the grammar node.
/// </summary>
/// <param name="p">Parent master grammar.</param>
public MetricExpr(MasterGrammar p) : base(p)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var metricExpr = new NonTerminal("Metric expression", typeof(TransientAstNode));
var metricExprTimeConst = new NonTerminal("Total-time const (metric expression)", typeof(FunctionTermAstNode));
var metricExprNumber = new NonTerminal("Number term (metric expression)", typeof(NumberTermAstNode));
var metricExprFuncIdentifier = new NonTerminal("Function term (metric expression)", typeof(FunctionTermAstNode));
var metricExprComplex = new NonTerminal("Complex metric expression", typeof(TransientAstNode));
var metricExprComplexBase = new NonTerminal("Complex metric expression base", typeof(TransientAstNode));
var metricExprViolatedBase = new NonTerminal("Preference violation expression (metric expression)", typeof(MetricPreferenceViolationAstNode));
var metricExprFunctionBase = new NonTerminal("Function term (metric expression)", typeof(FunctionTermAstNode));
var metricOpBase = new NonTerminal("Numeric operation base (metric expression)", typeof(TransientAstNode));
var functionIdentifier = new IdentifierTerminal("Function identifier", IdentifierType.CONSTANT);
var number = new NumberLiteral("Number");
var preferenceName = new IdentifierTerminal("Preference name", IdentifierType.CONSTANT);
// USED SUB-TREES
var functionTerm = new FunctionTermC(p, BForm.BASE);
var numericOp = new NumericOp(p, metricExpr, BForm.BASE);
// RULES
metricExpr.Rule = metricExprTimeConst | metricExprNumber | metricExprFuncIdentifier | metricExprComplex;
metricExprTimeConst.Rule = p.ToTerm("total-time");
metricExprNumber.Rule = number;
metricExprFuncIdentifier.Rule = functionIdentifier;
metricExprComplex.Rule = p.ToTerm("(") + metricExprComplexBase + ")";
metricExprComplexBase.Rule = metricExprViolatedBase | metricExprFunctionBase | metricOpBase;
metricExprViolatedBase.Rule = p.ToTerm("is-violated") + preferenceName;
metricExprFunctionBase.Rule = functionTerm;
metricOpBase.Rule = numericOp;
p.MarkTransient(metricExpr, metricExprComplex, metricExprComplexBase, metricExprFunctionBase, metricOpBase);
Rule = metricExpr;
}
/// <summary>
/// Constructs the value or term rule from the specified parameters.
/// </summary>
/// <param name="p">Parent master grammar.</param>
/// <param name="numericExpr">Numeric expression.</param>
/// <param name="durationVarExpr">Duration variable..</param>
/// <returns>Value or term grammar rule.</returns>
public static NonTerminal ConstructValueOrTermRule(MasterGrammar p, NonTerminal numericExpr, NonTerminal durationVarExpr = null)
{
// NON-TERMINAL AND TERMINAL SYMBOLS
var valueOrTerm = new NonTerminal("Value/term", typeof(TransientAstNode));
var valueOrTermComplex = new NonTerminal("Complex value/term", typeof(TransientAstNode));
var valueOrTermComplexBase = new NonTerminal("Complex value/term base", typeof(TransientAstNode));
var valueOrTermIdentifier = new NonTerminal("Identifier value/term", typeof(IdentifierTermAstNode));
var valueOrTermNumber = new NonTerminal("Number value/term", typeof(NumberTermAstNode));
var valueOrTermFunction = new NonTerminal("Functional value/term", typeof(TransientAstNode));
var valueOrTermNumericOp = new NonTerminal("Numeric-op value/term", typeof(TransientAstNode));
var varOrConstOrFuncIdentifier = new IdentifierTerminal("Variable or constant or function identifier", IdentifierType.VARIABLE_OR_CONSTANT);
var number = new NumberLiteral("Number");
// USED SUB-TREES
var numericOpBase = new NumericOp(p, numericExpr, BForm.BASE);
var termFunctionBase = new FunctionTerm(p, BForm.BASE);
// RULES
valueOrTerm.Rule = valueOrTermIdentifier | valueOrTermNumber | valueOrTermComplex;
valueOrTermComplex.Rule = p.ToTerm("(") + valueOrTermComplexBase + ")";
valueOrTermComplexBase.Rule = valueOrTermFunction | valueOrTermNumericOp;
valueOrTermIdentifier.Rule = varOrConstOrFuncIdentifier;
valueOrTermNumber.Rule = number;
valueOrTermFunction.Rule = termFunctionBase;
valueOrTermNumericOp.Rule = numericOpBase;
if (durationVarExpr != null)
{
valueOrTerm.Rule |= durationVarExpr;
}
p.MarkTransient(valueOrTerm, valueOrTermComplex, valueOrTermComplexBase, valueOrTermFunction, valueOrTermNumericOp, numericOpBase);
return(valueOrTerm);
}