/// <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 ValueOrTermT(MasterGrammar p) : base(p) { var durationVar = new NonTerminal("Duration variable term (duration numeric expression)", typeof(DurationVariableTermAstNode)) { Rule = p.ToTerm("?duration") }; Rule = ValueOrTerm.ConstructValueOrTermRule(p, new NumericExprDa(p), durationVar); }
/// <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; }
/// <summary> /// Constructs the primitive effect rule from the specified parameters. /// </summary> /// <param name="p">Parent master grammar.</param> /// <param name="bForm">Block form.</param> /// <param name="valueOrTermForAssign">Value or term for an assignment.</param> /// <param name="numericExprForAssign">Numeric expression for an assignment.</param> /// <returns>Primitive effect grammar rule.</returns> public static NonTerminal ConstructPEffectRule(MasterGrammar p, BForm bForm, NonTerminal valueOrTermForAssign, NonTerminal numericExprForAssign) { // NON-TERMINAL AND TERMINAL SYMBOLS var pEffect = new NonTerminal("P-effect", typeof(TransientAstNode)); var pEffectBase = new NonTerminal("P-effect base", typeof(TransientAstNode)); var atomicFormulaPEffect = new NonTerminal("Atomic formula (p-effect)", typeof(TransientAstNode)); var atomicFormulaPEffectBase = new NonTerminal("Atomic formula base (p-effect)", typeof(TransientAstNode)); var predicatePEffectBase = new NonTerminal("Predicate (p-effect)", typeof(PredicatePEffectAstNode)); var predicateArguments = new NonTerminal("Predicate arguments", typeof(TransientAstNode)); var equalsOpPEffectBase = new NonTerminal("Equals-op (p-effect)", typeof(EqualsOpPEffectAstNode)); var notPEffectBase = new NonTerminal("NOT expression (p-effect)", typeof(NotPEffectAstNode)); var assignPEffectBase = new NonTerminal("General assign expression (p-effect)", typeof(TransientAstNode)); var objOrNumAssign = new NonTerminal("Numeric or object assign operator (p-effect)", typeof(AssignPEffectAstNode)); var onlyNumAssign = new NonTerminal("Numeric assign operator (p-effect)", typeof(AssignPEffectAstNode)); var numAssignOp = new NonTerminal("Assign operation", typeof(TransientAstNode)); var assignOpArg1 = new NonTerminal("Assign operation first argument", typeof(TransientAstNode)); var assignOpArg2 = new NonTerminal("Assign operation second argument", typeof(TransientAstNode)); var assignOpArg2Num = new NonTerminal("Assign operation second numeric argument", typeof(TransientAstNode)); var assignOpFuncIdentif = new NonTerminal("Function identifier for ASSIGN operation", typeof(FunctionTermAstNode)); var undefinedFuncVal = new NonTerminal("Undefined function value", typeof(UndefinedFuncValAstNode)); var predicateIdentifier = new IdentifierTerminal("Predicate identifier", IdentifierType.CONSTANT); var functionIdentifier = new IdentifierTerminal("Function identifier", IdentifierType.CONSTANT); // USED SUB-TREES var valueOrTerm = new ValueOrTerm(p); var predFuncTermFunction = new FunctionTerm(p); var term = new Term(p); // RULES pEffect.Rule = p.ToTerm("(") + pEffectBase + ")"; pEffectBase.Rule = atomicFormulaPEffectBase | notPEffectBase | assignPEffectBase; atomicFormulaPEffect.Rule = p.ToTerm("(") + atomicFormulaPEffectBase + ")"; atomicFormulaPEffectBase.Rule = predicatePEffectBase | equalsOpPEffectBase; predicatePEffectBase.Rule = predicateIdentifier + predicateArguments; predicateArguments.Rule = p.MakeStarRule(predicateArguments, term); equalsOpPEffectBase.Rule = p.ToTerm("=") + valueOrTerm + valueOrTerm; notPEffectBase.Rule = p.ToTerm("not") + atomicFormulaPEffect; assignPEffectBase.Rule = objOrNumAssign | onlyNumAssign; objOrNumAssign.Rule = p.ToTerm("assign") + assignOpArg1 + assignOpArg2; onlyNumAssign.Rule = numAssignOp + assignOpArg1 + assignOpArg2Num; assignOpArg1.Rule = assignOpFuncIdentif | predFuncTermFunction; assignOpArg2.Rule = undefinedFuncVal | valueOrTermForAssign; assignOpFuncIdentif.Rule = functionIdentifier; assignOpArg2Num.Rule = numericExprForAssign; numAssignOp.Rule = p.ToTerm("scale-up") | "scale-down" | "increase" | "decrease"; undefinedFuncVal.Rule = p.ToTerm("undefined"); p.MarkTransient(pEffect, pEffectBase, atomicFormulaPEffect, atomicFormulaPEffectBase, assignPEffectBase, assignOpArg1, assignOpArg2, assignOpArg2Num); return((bForm == BForm.BASE) ? pEffectBase : pEffect); }