/// <summary> /// Constructor of the grammar node. /// </summary> /// <param name="p">Parent master grammar.</param> /// <param name="bForm">Block form.</param> public DerivedPred(MasterGrammar p, BForm bForm) : base(p, bForm) { // NON-TERMINAL AND TERMINAL SYMBOLS var derivedDef = new NonTerminal("Derived predicate definition", typeof(TransientAstNode)); var derivedDefBase = new NonTerminal("Derived predicate definition", typeof(DomainDerivedPredAstNode)); var predicateSkeleton = new NonTerminal("Derived predicate skeleton", typeof(TransientAstNode)); var predicateSkeletonBase = new NonTerminal("Derived predicate skeleton", typeof(PredicateSkeletonAstNode)); var predicateIdentifier = new IdentifierTerminal("Predicate identifier", IdentifierType.CONSTANT); // USED SUB-TREES var gd = new Gd(p); var typedList = new TypedList(p); // RULES derivedDef.Rule = p.ToTerm("(") + derivedDefBase + ")"; derivedDefBase.Rule = p.ToTerm(":derived") + predicateSkeleton + gd; predicateSkeleton.Rule = p.ToTerm("(") + predicateSkeletonBase + ")"; predicateSkeletonBase.Rule = predicateIdentifier + typedList; p.MarkTransient(derivedDef, predicateSkeleton); Rule = (bForm == BForm.BASE) ? derivedDefBase : derivedDef; }
/// <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> /// <param name="bForm">Block form.</param> public Effect(MasterGrammar p, BForm bForm) : base(p, bForm) { // NON-TERMINAL AND TERMINAL SYMBOLS var effect = new NonTerminal("Effect", typeof(TransientAstNode)); var effectBase = new NonTerminal("Effect base", typeof(TransientAstNode)); var andCEffectsBase = new NonTerminal("AND expression (c-effects)", typeof(AndCEffectsAstNode)); var cEffectStarList = new NonTerminal("C-effects list", typeof(TransientAstNode)); var cEffect = new NonTerminal("C-effect", typeof(TransientAstNode)); var cEffectBase = new NonTerminal("C-effect base", typeof(TransientAstNode)); var forallCEffectBase = new NonTerminal("FORALL expression (c-effect)", typeof(ForallCEffectAstNode)); var whenCEffectBase = new NonTerminal("WHEN expression (c-effect)", typeof(WhenCEffectAstNode)); var condEffect = new NonTerminal("Cond-Effect", typeof(TransientAstNode)); var condEffectBase = new NonTerminal("Cond-Effect base", typeof(TransientAstNode)); var andPEffectsBase = new NonTerminal("AND expression (p-effects)", typeof(AndPEffectsAstNode)); var pEffectStarList = new NonTerminal("P-effects star-list", typeof(TransientAstNode)); // USED SUB-TREES var typedList = new TypedList(p); var gd = new Gd(p); var pEffect = new PEffect(p, BForm.FULL); var pEffectBase = new PEffect(p, BForm.BASE); // RULES // (general) effect - c-effect or a list of c-effects effect.Rule = p.ToTerm("(") + effectBase + ")"; effectBase.Rule = cEffectBase | andCEffectsBase; andCEffectsBase.Rule = p.ToTerm("and") + cEffectStarList; cEffectStarList.Rule = p.MakeStarRule(cEffectStarList, cEffect); // c-effect (allowing conditional effects) cEffect.Rule = p.ToTerm("(") + cEffectBase + ")"; cEffectBase.Rule = forallCEffectBase | whenCEffectBase | pEffectBase; forallCEffectBase.Rule = p.ToTerm("forall") + "(" + typedList + ")" + effect; whenCEffectBase.Rule = p.ToTerm("when") + gd + condEffect; // cond-effect (not allowing inner conditional effects) condEffect.Rule = p.ToTerm("(") + condEffectBase + ")"; condEffectBase.Rule = pEffectBase | andPEffectsBase; andPEffectsBase.Rule = p.ToTerm("and") + pEffectStarList; pEffectStarList.Rule = p.MakeStarRule(pEffectStarList, pEffect); p.MarkTransient(effect, effectBase, cEffect, cEffectBase, condEffect, condEffectBase); Rule = (bForm == BForm.BASE) ? effectBase : effect; }
/// <summary> /// Constructor of the grammar node. /// </summary> /// <param name="p">Parent master grammar.</param> public ConGd(MasterGrammar p) : base(p) { // NON-TERMINAL AND TERMINAL SYMBOLS var conGd = new NonTerminal("Con-GD", typeof(TransientAstNode)); var conGdBase = new NonTerminal("Con-GD base", typeof(TransientAstNode)); var conGdStarList = new NonTerminal("Con-GD star-list", typeof(TransientAstNode)); var andConGdBase = new NonTerminal("AND expression (con-GDs)", typeof(AndConGdAstNode)); var forallConGdBase = new NonTerminal("FORALL expression (con-GDs)", typeof(ForallConGdAstNode)); var atEndConGdBase = new NonTerminal("AT-END expression (con-GD)", typeof(AtEndConGdAstNode)); var alwaysConGdBase = new NonTerminal("ALWAYS expression (con-GD)", typeof(AlwaysConGdAstNode)); var sometimeConGdBase = new NonTerminal("SOMETIME expression (con-GD)", typeof(SometimeConGdAstNode)); var withinConGdBase = new NonTerminal("WITHIN expression (con-GD)", typeof(WithinConGdAstNode)); var atMostOnceConGdBase = new NonTerminal("AT-MOST-ONCE expression (con-GD)", typeof(AtMostOnceConGdAstNode)); var sometimeAfterConGdBase = new NonTerminal("SOMETIME-AFTER expression (con-GD)", typeof(SometimeAfterConGdAstNode)); var sometimeBeforeConGdBase = new NonTerminal("SOMETIME-BEFORE expression (con-GD)", typeof(SometimeBeforeConGdAstNode)); var alwaysWithinConGdBase = new NonTerminal("ALWAYS-WITHIN expression (con-GD)", typeof(AlwaysWithinConGdAstNode)); var holdDuringConGdBase = new NonTerminal("HOLD-DURING expression (con-GD)", typeof(HoldDuringConGdAstNode)); var holdAfterConGdBase = new NonTerminal("HOLD-AFTER expression (con-GD)", typeof(HoldAfterConGdAstNode)); var number = new NumberLiteral("Number"); // USED SUB-TREES var typedList = new TypedList(p); var gd = new Gd(p); // RULES conGd.Rule = p.ToTerm("(") + conGdBase + ")"; conGdBase.Rule = andConGdBase | forallConGdBase | atEndConGdBase | alwaysConGdBase | sometimeConGdBase | withinConGdBase | atMostOnceConGdBase | sometimeAfterConGdBase | sometimeBeforeConGdBase | alwaysWithinConGdBase | holdDuringConGdBase | holdAfterConGdBase; andConGdBase.Rule = p.ToTerm("and") + conGdStarList; forallConGdBase.Rule = p.ToTerm("forall") + "(" + typedList + ")" + conGd; atEndConGdBase.Rule = p.ToTerm("at") + p.ToTerm("end") + gd; alwaysConGdBase.Rule = p.ToTerm("always") + gd; sometimeConGdBase.Rule = p.ToTerm("sometime") + gd; withinConGdBase.Rule = p.ToTerm("within") + number + gd; atMostOnceConGdBase.Rule = p.ToTerm("at-most-once") + gd; sometimeAfterConGdBase.Rule = p.ToTerm("sometime-after") + gd + gd; sometimeBeforeConGdBase.Rule = p.ToTerm("sometime-before") + gd + gd; alwaysWithinConGdBase.Rule = p.ToTerm("always-within") + number + gd + gd; holdDuringConGdBase.Rule = p.ToTerm("hold-during") + number + number + gd; holdAfterConGdBase.Rule = p.ToTerm("hold-after") + number + gd; conGdStarList.Rule = p.MakeStarRule(conGdStarList, conGd); p.MarkTransient(conGd, conGdBase); Rule = conGd; }
/// <summary> /// Constructor of the grammar node. /// </summary> /// <param name="p">Parent master grammar.</param> public DaGd(MasterGrammar p) : base(p) { // NON-TERMINAL AND TERMINAL SYMBOLS var daGd = new NonTerminal("Da-GD", typeof(TransientAstNode)); var daGdBase = new NonTerminal("Da-GD base", typeof(TransientAstNode)); var daGdStarList = new NonTerminal("Da-GD star-list", typeof(TransientAstNode)); var andDaGdBase = new NonTerminal("AND expression (da-GDs)", typeof(AndDaGdAstNode)); var forallDaGdBase = new NonTerminal("FORALL expression (da-GD)", typeof(ForallDaGdAstNode)); var prefDaGdBase = new NonTerminal("Preference (da-GD)", typeof(PreferenceDaGdAstNode)); var prefNameOrEmpty = new NonTerminal("Optional preference name", typeof(TransientAstNode)); var prefName = new IdentifierTerminal("Preference name", IdentifierType.CONSTANT); var timedDaGd = new NonTerminal("Timed-da-GD", typeof(TransientAstNode)); var timedDaGdBase = new NonTerminal("Timed-da-GD base", typeof(TransientAstNode)); var atTimedDaGd = new NonTerminal("AT expression (timed-da-GD)", typeof(AtTimedDaGdAstNode)); var overTimedDaGd = new NonTerminal("OVER expression (timed-da-GD)", typeof(OverTimedDaGdAstNode)); var timeSpecifier = new NonTerminal("Time specifier", typeof(TransientAstNode)); var intervalSpecifier = new NonTerminal("Interval specifier", typeof(TransientAstNode)); // USED SUB-TREES var typedList = new TypedList(p); var gd = new Gd(p); // RULES daGd.Rule = p.ToTerm("(") + daGdBase + ")"; daGdBase.Rule = andDaGdBase | forallDaGdBase | prefDaGdBase | timedDaGdBase; andDaGdBase.Rule = p.ToTerm("and") + daGdStarList; forallDaGdBase.Rule = p.ToTerm("forall") + "(" + typedList + ")" + daGd; prefDaGdBase.Rule = p.ToTerm("preference") + prefNameOrEmpty + timedDaGd; prefNameOrEmpty.Rule = prefName | p.Empty; timedDaGd.Rule = p.ToTerm("(") + timedDaGdBase + ")"; timedDaGdBase.Rule = atTimedDaGd | overTimedDaGd; atTimedDaGd.Rule = p.ToTerm("at") + timeSpecifier + gd; overTimedDaGd.Rule = p.ToTerm("over") + intervalSpecifier + gd; timeSpecifier.Rule = p.ToTerm("start") | p.ToTerm("end"); intervalSpecifier.Rule = p.ToTerm("all"); daGdStarList.Rule = p.MakeStarRule(daGdStarList, daGd); p.MarkTransient(daGd, daGdBase, timedDaGd, timedDaGdBase); Rule = daGd; }