diff options
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java')
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java | 1267 |
1 files changed, 944 insertions, 323 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java index 1ad39fd7..5cb73796 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
3 | */ | 3 | */ |
4 | package org.eclipse.viatra.solver.language.serializer; | 4 | package org.eclipse.viatra.solver.language.serializer; |
5 | 5 | ||
@@ -8,43 +8,48 @@ import java.util.Set; | |||
8 | import org.eclipse.emf.ecore.EObject; | 8 | import org.eclipse.emf.ecore.EObject; |
9 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | 10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; |
11 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; |
12 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; |
13 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; |
14 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; |
15 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; |
16 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition; |
17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | 17 | import org.eclipse.viatra.solver.language.solverLanguage.Call; |
18 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | 18 | import org.eclipse.viatra.solver.language.solverLanguage.Case; |
19 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | 19 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition; |
20 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | 20 | import org.eclipse.viatra.solver.language.solverLanguage.Comparison; |
21 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | 21 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; |
22 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | 22 | import org.eclipse.viatra.solver.language.solverLanguage.Count; |
23 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | 23 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition; |
24 | import org.eclipse.viatra.solver.language.solverLanguage.False; | 24 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; |
25 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | 25 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral; |
26 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | 26 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; |
27 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | 27 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition; |
28 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | 28 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; |
29 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | 29 | import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition; |
30 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | 30 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition; |
31 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | 31 | import org.eclipse.viatra.solver.language.solverLanguage.IfElse; |
32 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | 32 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; |
33 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | 33 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; |
34 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | 34 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; |
35 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | 35 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition; |
36 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | 36 | import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity; |
37 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; | ||
38 | import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition; | ||
39 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
40 | import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral; | ||
41 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition; | ||
42 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | ||
37 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | 43 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; |
38 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | 44 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; |
39 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
40 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
41 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 45 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
42 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | 46 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; |
43 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | 47 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; |
44 | import org.eclipse.viatra.solver.language.solverLanguage.True; | 48 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; |
45 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | 49 | import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument; |
46 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | 50 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; |
47 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | 51 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; |
52 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition; | ||
48 | import org.eclipse.xtext.Action; | 53 | import org.eclipse.xtext.Action; |
49 | import org.eclipse.xtext.Parameter; | 54 | import org.eclipse.xtext.Parameter; |
50 | import org.eclipse.xtext.ParserRule; | 55 | import org.eclipse.xtext.ParserRule; |
@@ -67,119 +72,157 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
67 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); | 72 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); |
68 | if (epackage == SolverLanguagePackage.eINSTANCE) | 73 | if (epackage == SolverLanguagePackage.eINSTANCE) |
69 | switch (semanticObject.eClass().getClassifierID()) { | 74 | switch (semanticObject.eClass().getClassifierID()) { |
70 | case SolverLanguagePackage.ALL_INSTANCES: | 75 | case SolverLanguagePackage.AGGREGATION: |
71 | sequence_AllInstances(context, (AllInstances) semanticObject); | 76 | sequence_Aggregation(context, (Aggregation) semanticObject); |
72 | return; | 77 | return; |
73 | case SolverLanguagePackage.ALL_OBJECTS: | 78 | case SolverLanguagePackage.ARGUMENT_LIST: |
74 | sequence_AllObjects(context, (AllObjects) semanticObject); | 79 | sequence_ArgumentList(context, (ArgumentList) semanticObject); |
75 | return; | 80 | return; |
76 | case SolverLanguagePackage.BASIC_INTERPRETATION: | 81 | case SolverLanguagePackage.ASSERTION: |
77 | sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject); | 82 | sequence_AssertionOrDefinition(context, (Assertion) semanticObject); |
78 | return; | 83 | return; |
79 | case SolverLanguagePackage.BOOLEAN_FALSE: | 84 | case SolverLanguagePackage.BINARY_EXPRESSION: |
80 | sequence_BooleanValue(context, (BooleanFalse) semanticObject); | 85 | sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject); |
81 | return; | 86 | return; |
82 | case SolverLanguagePackage.BOOLEAN_OBJECT: | 87 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: |
83 | sequence_BooleanObject(context, (BooleanObject) semanticObject); | 88 | sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject); |
84 | return; | 89 | return; |
85 | case SolverLanguagePackage.BOOLEAN_SYMBOL: | 90 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: |
86 | sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject); | 91 | sequence_BoundedScopeDefinition(context, (BoundedScopeDefinition) semanticObject); |
87 | return; | 92 | return; |
88 | case SolverLanguagePackage.BOOLEAN_TRUE: | 93 | case SolverLanguagePackage.CALL: |
89 | sequence_BooleanValue(context, (BooleanTrue) semanticObject); | 94 | sequence_Call(context, (Call) semanticObject); |
90 | return; | 95 | return; |
91 | case SolverLanguagePackage.CLASS_INTERPRETATION: | 96 | case SolverLanguagePackage.CASE: |
92 | sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject); | 97 | if (rule == grammarAccess.getCaseRule()) { |
98 | sequence_Case(context, (Case) semanticObject); | ||
99 | return; | ||
100 | } | ||
101 | else if (action == grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()) { | ||
102 | sequence_DisjunctiveExpression_Switch_1_1_3(context, (Case) semanticObject); | ||
103 | return; | ||
104 | } | ||
105 | else break; | ||
106 | case SolverLanguagePackage.CLASS_DEFINITION: | ||
107 | sequence_ClassDefinition(context, (ClassDefinition) semanticObject); | ||
93 | return; | 108 | return; |
94 | case SolverLanguagePackage.CONSTRAINT: | 109 | case SolverLanguagePackage.COMPARISON: |
95 | sequence_Constraint(context, (Constraint) semanticObject); | 110 | sequence_ComparisonExpression(context, (Comparison) semanticObject); |
96 | return; | 111 | return; |
97 | case SolverLanguagePackage.DEFAULT_INTERPRETATION: | 112 | case SolverLanguagePackage.CONJUNCTION: |
98 | sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject); | 113 | sequence_ConjunctiveExpression(context, (Conjunction) semanticObject); |
99 | return; | 114 | return; |
100 | case SolverLanguagePackage.ENUM_INTERPRETATION: | 115 | case SolverLanguagePackage.COUNT: |
101 | sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject); | 116 | sequence_Count(context, (Count) semanticObject); |
102 | return; | 117 | return; |
103 | case SolverLanguagePackage.EQUALS_SYMBOL: | 118 | case SolverLanguagePackage.DEFAULT_DEFINITION: |
104 | sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject); | 119 | sequence_DefaultDefinition(context, (DefaultDefinition) semanticObject); |
105 | return; | 120 | return; |
106 | case SolverLanguagePackage.ERROR: | 121 | case SolverLanguagePackage.DISJUNCTION: |
107 | sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject); | 122 | sequence_DisjunctiveExpression(context, (Disjunction) semanticObject); |
108 | return; | 123 | return; |
109 | case SolverLanguagePackage.EXIST_SYMBOL: | 124 | case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: |
110 | sequence_ExistSymbol(context, (ExistSymbol) semanticObject); | 125 | sequence_EmptyIntervalLiteral(context, (EmptyIntervalLiteral) semanticObject); |
111 | return; | 126 | return; |
112 | case SolverLanguagePackage.FALSE: | 127 | case SolverLanguagePackage.EXACT_MULTIPLICITY: |
113 | sequence_TruthValue(context, (False) semanticObject); | 128 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); |
114 | return; | 129 | return; |
115 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: | 130 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: |
116 | sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject); | 131 | sequence_ExactScopeDefinition(context, (ExactScopeDefinition) semanticObject); |
117 | return; | 132 | return; |
118 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: | 133 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: |
119 | sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject); | 134 | sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject); |
120 | return; | 135 | return; |
121 | case SolverLanguagePackage.INT_OBJECT: | 136 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: |
122 | sequence_IntObject(context, (IntObject) semanticObject); | 137 | sequence_ExternMetricDefinition(context, (ExternMetricDefinition) semanticObject); |
123 | return; | 138 | return; |
124 | case SolverLanguagePackage.INTEGER_SYMBOL: | 139 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: |
125 | sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject); | 140 | sequence_ExternPredicateDefinition(context, (ExternPredicateDefinition) semanticObject); |
126 | return; | 141 | return; |
127 | case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: | 142 | case SolverLanguagePackage.IF_ELSE: |
128 | sequence_ClosureType(context, (IrreflexiveClosure) semanticObject); | 143 | sequence_IfElse(context, (IfElse) semanticObject); |
129 | return; | 144 | return; |
130 | case SolverLanguagePackage.MODEL_SYMBOL: | 145 | case SolverLanguagePackage.INFINITY_LITERAL: |
131 | sequence_ModelSymbol(context, (ModelSymbol) semanticObject); | 146 | sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject); |
132 | return; | 147 | return; |
133 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION: | 148 | case SolverLanguagePackage.INTERVAL: |
134 | sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject); | 149 | sequence_Interval(context, (Interval) semanticObject); |
135 | return; | 150 | return; |
136 | case SolverLanguagePackage.NAMED_OBJECT: | 151 | case SolverLanguagePackage.LOGIC_LITERAL: |
137 | sequence_NamedObject(context, (NamedObject) semanticObject); | 152 | sequence_LogicLiteral(context, (LogicLiteral) semanticObject); |
138 | return; | 153 | return; |
139 | case SolverLanguagePackage.NEGATIVE: | 154 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: |
140 | sequence_Polarity(context, (Negative) semanticObject); | 155 | sequence_LowerBoundedScopeDefinition(context, (LowerBoundedScopeDefinition) semanticObject); |
141 | return; | 156 | return; |
142 | case SolverLanguagePackage.PARAMETER: | 157 | case SolverLanguagePackage.MANY_MULTIPLICITY: |
143 | sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject); | 158 | sequence_ManyMultiplicity(context, (ManyMultiplicity) semanticObject); |
144 | return; | 159 | return; |
145 | case SolverLanguagePackage.PATTERN_BODY: | 160 | case SolverLanguagePackage.MEMBER_DEFINITION: |
146 | sequence_PatternBody(context, (PatternBody) semanticObject); | 161 | sequence_MemberDefinition(context, (MemberDefinition) semanticObject); |
147 | return; | 162 | return; |
148 | case SolverLanguagePackage.POSITIVE: | 163 | case SolverLanguagePackage.METRIC_DEFINITION: |
149 | sequence_Polarity(context, (Positive) semanticObject); | 164 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { |
165 | sequence_AssertionOrDefinition(context, (MetricDefinition) semanticObject); | ||
166 | return; | ||
167 | } | ||
168 | else if (rule == grammarAccess.getStatementRule()) { | ||
169 | sequence_AssertionOrDefinition_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
170 | return; | ||
171 | } | ||
172 | else if (rule == grammarAccess.getMetricDefinitionRule()) { | ||
173 | sequence_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
174 | return; | ||
175 | } | ||
176 | else break; | ||
177 | case SolverLanguagePackage.NAMED_ELEMENT: | ||
178 | sequence_NamedElement(context, (NamedElement) semanticObject); | ||
150 | return; | 179 | return; |
151 | case SolverLanguagePackage.PREDICATE: | 180 | case SolverLanguagePackage.NUMERIC_LITERAL: |
152 | sequence_Predicate(context, (Predicate) semanticObject); | 181 | sequence_NumericLiteral(context, (NumericLiteral) semanticObject); |
153 | return; | 182 | return; |
183 | case SolverLanguagePackage.OBJECTIVE_DEFINITION: | ||
184 | sequence_ObjectiveDefinition(context, (ObjectiveDefinition) semanticObject); | ||
185 | return; | ||
186 | case SolverLanguagePackage.PREDICATE_DEFINITION: | ||
187 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | ||
188 | sequence_AssertionOrDefinition(context, (PredicateDefinition) semanticObject); | ||
189 | return; | ||
190 | } | ||
191 | else if (rule == grammarAccess.getStatementRule()) { | ||
192 | sequence_AssertionOrDefinition_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
193 | return; | ||
194 | } | ||
195 | else if (rule == grammarAccess.getPredicateDefinitionRule()) { | ||
196 | sequence_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
197 | return; | ||
198 | } | ||
199 | else break; | ||
154 | case SolverLanguagePackage.PROBLEM: | 200 | case SolverLanguagePackage.PROBLEM: |
155 | sequence_Problem(context, (Problem) semanticObject); | 201 | sequence_Problem(context, (Problem) semanticObject); |
156 | return; | 202 | return; |
157 | case SolverLanguagePackage.REAL_OBJECT: | 203 | case SolverLanguagePackage.REFERENCE: |
158 | sequence_RealObject(context, (RealObject) semanticObject); | 204 | sequence_Reference(context, (Reference) semanticObject); |
159 | return; | ||
160 | case SolverLanguagePackage.REAL_SYMBOL: | ||
161 | sequence_RealSymbol(context, (RealSymbol) semanticObject); | ||
162 | return; | 205 | return; |
163 | case SolverLanguagePackage.REFLEXIVE_CLOSURE: | 206 | case SolverLanguagePackage.STAR_ARGUMENT: |
164 | sequence_ClosureType(context, (ReflexiveClosure) semanticObject); | 207 | sequence_StarArgument(context, (StarArgument) semanticObject); |
165 | return; | 208 | return; |
166 | case SolverLanguagePackage.STRING_OBJECT: | 209 | case SolverLanguagePackage.STRING_LITERAL: |
167 | sequence_StringObject(context, (StringObject) semanticObject); | 210 | sequence_StringLiteral(context, (StringLiteral) semanticObject); |
168 | return; | 211 | return; |
169 | case SolverLanguagePackage.STRING_SYMBOL: | 212 | case SolverLanguagePackage.SWITCH: |
170 | sequence_StringSymbol(context, (StringSymbol) semanticObject); | 213 | sequence_DisjunctiveExpression(context, (Switch) semanticObject); |
171 | return; | 214 | return; |
172 | case SolverLanguagePackage.TRUE: | 215 | case SolverLanguagePackage.TYPED_ARGUMENT: |
173 | sequence_TruthValue(context, (True) semanticObject); | 216 | sequence_TypedArgument(context, (TypedArgument) semanticObject); |
174 | return; | 217 | return; |
175 | case SolverLanguagePackage.UNKNOWN: | 218 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: |
176 | sequence_TruthValue(context, (Unknown) semanticObject); | 219 | sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject); |
177 | return; | 220 | return; |
178 | case SolverLanguagePackage.UNNAMED_OBJECT: | 221 | case SolverLanguagePackage.UNARY_EXPRESSION: |
179 | sequence_UnnamedObject(context, (UnnamedObject) semanticObject); | 222 | sequence_UnaryExpression(context, (UnaryExpression) semanticObject); |
180 | return; | 223 | return; |
181 | case SolverLanguagePackage.VARIABLE: | 224 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: |
182 | sequence_Variable(context, (Variable) semanticObject); | 225 | sequence_UnnamedErrorPrediateDefinition(context, (UnnamedErrorPrediateDefinition) semanticObject); |
183 | return; | 226 | return; |
184 | } | 227 | } |
185 | if (errorAcceptor != null) | 228 | if (errorAcceptor != null) |
@@ -188,574 +231,1152 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
188 | 231 | ||
189 | /** | 232 | /** |
190 | * Contexts: | 233 | * Contexts: |
191 | * ComplexObject returns AllInstances | 234 | * AssertionOrDefinition.Assertion_1_0_0 returns BinaryExpression |
192 | * AllInstances returns AllInstances | 235 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression |
236 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns BinaryExpression | ||
237 | * Expression returns BinaryExpression | ||
238 | * DisjunctiveExpression returns BinaryExpression | ||
239 | * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression | ||
240 | * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression | ||
241 | * ConjunctiveExpression returns BinaryExpression | ||
242 | * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression | ||
243 | * ComparisonExpression returns BinaryExpression | ||
244 | * ComparisonExpression.Comparison_1_0 returns BinaryExpression | ||
245 | * AdditiveExpression returns BinaryExpression | ||
246 | * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression | ||
247 | * MultiplicativeExpression returns BinaryExpression | ||
248 | * MultiplicativeExpression.BinaryExpression_1_0 returns BinaryExpression | ||
249 | * ExponentialExpression returns BinaryExpression | ||
250 | * ExponentialExpression.BinaryExpression_1_0 returns BinaryExpression | ||
251 | * UnaryExpression returns BinaryExpression | ||
252 | * AggregationExpression returns BinaryExpression | ||
253 | * AtomicExpression returns BinaryExpression | ||
193 | * | 254 | * |
194 | * Constraint: | 255 | * Constraint: |
195 | * symbol=Symbol | 256 | * ( |
257 | * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) | | ||
258 | * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) | | ||
259 | * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=ExponentialExpression) | ||
260 | * ) | ||
196 | */ | 261 | */ |
197 | protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) { | 262 | protected void sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) { |
263 | genericSequencer.createSequence(context, semanticObject); | ||
264 | } | ||
265 | |||
266 | |||
267 | /** | ||
268 | * Contexts: | ||
269 | * AssertionOrDefinition.Assertion_1_0_0 returns Aggregation | ||
270 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation | ||
271 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Aggregation | ||
272 | * Expression returns Aggregation | ||
273 | * DisjunctiveExpression returns Aggregation | ||
274 | * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation | ||
275 | * DisjunctiveExpression.Case_1_1_0 returns Aggregation | ||
276 | * ConjunctiveExpression returns Aggregation | ||
277 | * ConjunctiveExpression.Conjunction_1_0 returns Aggregation | ||
278 | * ComparisonExpression returns Aggregation | ||
279 | * ComparisonExpression.Comparison_1_0 returns Aggregation | ||
280 | * AdditiveExpression returns Aggregation | ||
281 | * AdditiveExpression.BinaryExpression_1_0 returns Aggregation | ||
282 | * MultiplicativeExpression returns Aggregation | ||
283 | * MultiplicativeExpression.BinaryExpression_1_0 returns Aggregation | ||
284 | * ExponentialExpression returns Aggregation | ||
285 | * ExponentialExpression.BinaryExpression_1_0 returns Aggregation | ||
286 | * UnaryExpression returns Aggregation | ||
287 | * AggregationExpression returns Aggregation | ||
288 | * Aggregation returns Aggregation | ||
289 | * AtomicExpression returns Aggregation | ||
290 | * | ||
291 | * Constraint: | ||
292 | * (op=AggregationOp body=Expression condition=Expression) | ||
293 | */ | ||
294 | protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) { | ||
198 | if (errorAcceptor != null) { | 295 | if (errorAcceptor != null) { |
199 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES) | 296 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP) == ValueTransient.YES) |
200 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL)); | 297 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP)); |
298 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY) == ValueTransient.YES) | ||
299 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY)); | ||
300 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION) == ValueTransient.YES) | ||
301 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION)); | ||
201 | } | 302 | } |
202 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 303 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
203 | feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol()); | 304 | feeder.accept(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0(), semanticObject.getOp()); |
305 | feeder.accept(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
306 | feeder.accept(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0(), semanticObject.getCondition()); | ||
204 | feeder.finish(); | 307 | feeder.finish(); |
205 | } | 308 | } |
206 | 309 | ||
207 | 310 | ||
208 | /** | 311 | /** |
209 | * Contexts: | 312 | * Contexts: |
210 | * ComplexObject returns AllObjects | 313 | * ArgumentList returns ArgumentList |
211 | * AllObjects returns AllObjects | ||
212 | * | 314 | * |
213 | * Constraint: | 315 | * Constraint: |
214 | * {AllObjects} | 316 | * (arguments+=Argument arguments+=Argument*)? |
215 | */ | 317 | */ |
216 | protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) { | 318 | protected void sequence_ArgumentList(ISerializationContext context, ArgumentList semanticObject) { |
217 | genericSequencer.createSequence(context, semanticObject); | 319 | genericSequencer.createSequence(context, semanticObject); |
218 | } | 320 | } |
219 | 321 | ||
220 | 322 | ||
221 | /** | 323 | /** |
222 | * Contexts: | 324 | * Contexts: |
223 | * Statement returns BasicInterpretation | 325 | * Statement returns Assertion |
224 | * Interpretation returns BasicInterpretation | 326 | * AssertionOrDefinition returns Assertion |
225 | * BasicInterpretation returns BasicInterpretation | ||
226 | * | 327 | * |
227 | * Constraint: | 328 | * Constraint: |
228 | * (symbol=Symbol (objects+=ComplexObject objects+=ComplexObject*)? value=TruthValue) | 329 | * (body=AssertionOrDefinition_Assertion_1_0_0 range=Expression?) |
229 | */ | 330 | */ |
230 | protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) { | 331 | protected void sequence_AssertionOrDefinition(ISerializationContext context, Assertion semanticObject) { |
231 | genericSequencer.createSequence(context, semanticObject); | 332 | genericSequencer.createSequence(context, semanticObject); |
232 | } | 333 | } |
233 | 334 | ||
234 | 335 | ||
235 | /** | 336 | /** |
236 | * Contexts: | 337 | * Contexts: |
237 | * ComplexObject returns BooleanObject | 338 | * AssertionOrDefinition returns MetricDefinition |
238 | * Object returns BooleanObject | ||
239 | * DataObject returns BooleanObject | ||
240 | * BooleanObject returns BooleanObject | ||
241 | * Literal returns BooleanObject | ||
242 | * | 339 | * |
243 | * Constraint: | 340 | * Constraint: |
244 | * value=BooleanValue | 341 | * (head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) |
245 | */ | 342 | */ |
246 | protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) { | 343 | protected void sequence_AssertionOrDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
247 | if (errorAcceptor != null) { | 344 | if (errorAcceptor != null) { |
248 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES) | 345 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) |
249 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE)); | 346 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); |
347 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | ||
348 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | ||
250 | } | 349 | } |
251 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 350 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
252 | feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue()); | 351 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), semanticObject.getHead()); |
352 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody()); | ||
253 | feeder.finish(); | 353 | feeder.finish(); |
254 | } | 354 | } |
255 | 355 | ||
256 | 356 | ||
257 | /** | 357 | /** |
258 | * Contexts: | 358 | * Contexts: |
259 | * Symbol returns BooleanSymbol | 359 | * Statement returns MetricDefinition |
260 | * DataSymbol returns BooleanSymbol | ||
261 | * BooleanSymbol returns BooleanSymbol | ||
262 | * | 360 | * |
263 | * Constraint: | 361 | * Constraint: |
264 | * {BooleanSymbol} | 362 | * ((head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) | (type=MetricType head=Expression body=Expression)) |
265 | */ | 363 | */ |
266 | protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) { | 364 | protected void sequence_AssertionOrDefinition_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
267 | genericSequencer.createSequence(context, semanticObject); | 365 | genericSequencer.createSequence(context, semanticObject); |
268 | } | 366 | } |
269 | 367 | ||
270 | 368 | ||
271 | /** | 369 | /** |
272 | * Contexts: | 370 | * Contexts: |
273 | * BooleanValue returns BooleanFalse | 371 | * AssertionOrDefinition returns PredicateDefinition |
274 | * | 372 | * |
275 | * Constraint: | 373 | * Constraint: |
276 | * {BooleanFalse} | 374 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) |
277 | */ | 375 | */ |
278 | protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) { | 376 | protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
279 | genericSequencer.createSequence(context, semanticObject); | 377 | if (errorAcceptor != null) { |
378 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD) == ValueTransient.YES) | ||
379 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD)); | ||
380 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY) == ValueTransient.YES) | ||
381 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY)); | ||
382 | } | ||
383 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
384 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead()); | ||
385 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
386 | feeder.finish(); | ||
280 | } | 387 | } |
281 | 388 | ||
282 | 389 | ||
283 | /** | 390 | /** |
284 | * Contexts: | 391 | * Contexts: |
285 | * BooleanValue returns BooleanTrue | 392 | * Statement returns PredicateDefinition |
286 | * | 393 | * |
287 | * Constraint: | 394 | * Constraint: |
288 | * {BooleanTrue} | 395 | * ( |
396 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) | | ||
397 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) | ||
398 | * ) | ||
289 | */ | 399 | */ |
290 | protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) { | 400 | protected void sequence_AssertionOrDefinition_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
291 | genericSequencer.createSequence(context, semanticObject); | 401 | genericSequencer.createSequence(context, semanticObject); |
292 | } | 402 | } |
293 | 403 | ||
294 | 404 | ||
295 | /** | 405 | /** |
296 | * Contexts: | 406 | * Contexts: |
297 | * Statement returns ClassInterpretation | 407 | * Multiplicity returns BoundedMultiplicity |
298 | * Interpretation returns ClassInterpretation | 408 | * BoundedMultiplicity returns BoundedMultiplicity |
299 | * CDInterpretation returns ClassInterpretation | ||
300 | * ClassInterpretation returns ClassInterpretation | ||
301 | * | 409 | * |
302 | * Constraint: | 410 | * Constraint: |
303 | * (abstract?='abstract'? symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*) | 411 | * (lowerBound=INT upperBound=UpperMultiplicty) |
304 | */ | 412 | */ |
305 | protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) { | 413 | protected void sequence_BoundedMultiplicity(ISerializationContext context, BoundedMultiplicity semanticObject) { |
306 | genericSequencer.createSequence(context, semanticObject); | 414 | if (errorAcceptor != null) { |
415 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND) == ValueTransient.YES) | ||
416 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND)); | ||
417 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND) == ValueTransient.YES) | ||
418 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND)); | ||
419 | } | ||
420 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
421 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0(), semanticObject.getLowerBound()); | ||
422 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
423 | feeder.finish(); | ||
307 | } | 424 | } |
308 | 425 | ||
309 | 426 | ||
310 | /** | 427 | /** |
311 | * Contexts: | 428 | * Contexts: |
312 | * ClosureType returns IrreflexiveClosure | 429 | * Statement returns BoundedScopeDefinition |
430 | * ScopeDefinition returns BoundedScopeDefinition | ||
431 | * BoundedScopeDefinition returns BoundedScopeDefinition | ||
313 | * | 432 | * |
314 | * Constraint: | 433 | * Constraint: |
315 | * {IrreflexiveClosure} | 434 | * ((lowerBound=INT? type=[NamedElement|QualifiedName] upperBound=INT) | (upperBound=INT type=[NamedElement|QualifiedName] lowerBound=INT?)) |
316 | */ | 435 | */ |
317 | protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) { | 436 | protected void sequence_BoundedScopeDefinition(ISerializationContext context, BoundedScopeDefinition semanticObject) { |
318 | genericSequencer.createSequence(context, semanticObject); | 437 | genericSequencer.createSequence(context, semanticObject); |
319 | } | 438 | } |
320 | 439 | ||
321 | 440 | ||
322 | /** | 441 | /** |
323 | * Contexts: | 442 | * Contexts: |
324 | * ClosureType returns ReflexiveClosure | 443 | * AssertionOrDefinition.Assertion_1_0_0 returns Call |
444 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call | ||
445 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Call | ||
446 | * Expression returns Call | ||
447 | * DisjunctiveExpression returns Call | ||
448 | * DisjunctiveExpression.Disjunction_1_0_0 returns Call | ||
449 | * DisjunctiveExpression.Case_1_1_0 returns Call | ||
450 | * ConjunctiveExpression returns Call | ||
451 | * ConjunctiveExpression.Conjunction_1_0 returns Call | ||
452 | * ComparisonExpression returns Call | ||
453 | * ComparisonExpression.Comparison_1_0 returns Call | ||
454 | * AdditiveExpression returns Call | ||
455 | * AdditiveExpression.BinaryExpression_1_0 returns Call | ||
456 | * MultiplicativeExpression returns Call | ||
457 | * MultiplicativeExpression.BinaryExpression_1_0 returns Call | ||
458 | * ExponentialExpression returns Call | ||
459 | * ExponentialExpression.BinaryExpression_1_0 returns Call | ||
460 | * UnaryExpression returns Call | ||
461 | * AggregationExpression returns Call | ||
462 | * AtomicExpression returns Call | ||
463 | * Call returns Call | ||
325 | * | 464 | * |
326 | * Constraint: | 465 | * Constraint: |
327 | * {ReflexiveClosure} | 466 | * ( |
467 | * functor=Reference | ||
468 | * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
469 | * argumentList=ArgumentList | ||
470 | * ) | ||
328 | */ | 471 | */ |
329 | protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) { | 472 | protected void sequence_Call(ISerializationContext context, Call semanticObject) { |
330 | genericSequencer.createSequence(context, semanticObject); | 473 | genericSequencer.createSequence(context, semanticObject); |
331 | } | 474 | } |
332 | 475 | ||
333 | 476 | ||
334 | /** | 477 | /** |
335 | * Contexts: | 478 | * Contexts: |
336 | * Constraint returns Constraint | 479 | * Case returns Case |
480 | * | ||
481 | * Constraint: | ||
482 | * (condition=ConjunctiveExpression body=ConjunctiveExpression) | ||
483 | */ | ||
484 | protected void sequence_Case(ISerializationContext context, Case semanticObject) { | ||
485 | if (errorAcceptor != null) { | ||
486 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) | ||
487 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); | ||
488 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
489 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
490 | } | ||
491 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
492 | feeder.accept(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0(), semanticObject.getCondition()); | ||
493 | feeder.accept(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
494 | feeder.finish(); | ||
495 | } | ||
496 | |||
497 | |||
498 | /** | ||
499 | * Contexts: | ||
500 | * Statement returns ClassDefinition | ||
501 | * ClassDefinition returns ClassDefinition | ||
337 | * | 502 | * |
338 | * Constraint: | 503 | * Constraint: |
339 | * ((polarity=Polarity? symbol=ModelSymbol params+=Literal? params+=Literal*) | (closureType=ClosureType params+=Literal? params+=Literal*)) | 504 | * ( |
505 | * abstract?='abstract'? | ||
506 | * name=ID | ||
507 | * (superclasses+=[NamedElement|QualifiedName] superclasses+=[NamedElement|QualifiedName]*)? | ||
508 | * members+=MemberDefinition* | ||
509 | * ) | ||
340 | */ | 510 | */ |
341 | protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) { | 511 | protected void sequence_ClassDefinition(ISerializationContext context, ClassDefinition semanticObject) { |
342 | genericSequencer.createSequence(context, semanticObject); | 512 | genericSequencer.createSequence(context, semanticObject); |
343 | } | 513 | } |
344 | 514 | ||
345 | 515 | ||
346 | /** | 516 | /** |
347 | * Contexts: | 517 | * Contexts: |
348 | * Statement returns DefaultInterpretation | 518 | * AssertionOrDefinition.Assertion_1_0_0 returns Comparison |
349 | * Interpretation returns DefaultInterpretation | 519 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Comparison |
350 | * DefaultInterpretation returns DefaultInterpretation | 520 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Comparison |
521 | * Expression returns Comparison | ||
522 | * DisjunctiveExpression returns Comparison | ||
523 | * DisjunctiveExpression.Disjunction_1_0_0 returns Comparison | ||
524 | * DisjunctiveExpression.Case_1_1_0 returns Comparison | ||
525 | * ConjunctiveExpression returns Comparison | ||
526 | * ConjunctiveExpression.Conjunction_1_0 returns Comparison | ||
527 | * ComparisonExpression returns Comparison | ||
528 | * ComparisonExpression.Comparison_1_0 returns Comparison | ||
529 | * AdditiveExpression returns Comparison | ||
530 | * AdditiveExpression.BinaryExpression_1_0 returns Comparison | ||
531 | * MultiplicativeExpression returns Comparison | ||
532 | * MultiplicativeExpression.BinaryExpression_1_0 returns Comparison | ||
533 | * ExponentialExpression returns Comparison | ||
534 | * ExponentialExpression.BinaryExpression_1_0 returns Comparison | ||
535 | * UnaryExpression returns Comparison | ||
536 | * AggregationExpression returns Comparison | ||
537 | * AtomicExpression returns Comparison | ||
351 | * | 538 | * |
352 | * Constraint: | 539 | * Constraint: |
353 | * interpretation=BasicInterpretation | 540 | * (left=ComparisonExpression_Comparison_1_0 op=ComparisonOperator right=AdditiveExpression) |
354 | */ | 541 | */ |
355 | protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) { | 542 | protected void sequence_ComparisonExpression(ISerializationContext context, Comparison semanticObject) { |
356 | if (errorAcceptor != null) { | 543 | if (errorAcceptor != null) { |
357 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES) | 544 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT) == ValueTransient.YES) |
358 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION)); | 545 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT)); |
546 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP) == ValueTransient.YES) | ||
547 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP)); | ||
548 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT) == ValueTransient.YES) | ||
549 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT)); | ||
359 | } | 550 | } |
360 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 551 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
361 | feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation()); | 552 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), semanticObject.getLeft()); |
553 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0(), semanticObject.getOp()); | ||
554 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0(), semanticObject.getRight()); | ||
362 | feeder.finish(); | 555 | feeder.finish(); |
363 | } | 556 | } |
364 | 557 | ||
365 | 558 | ||
366 | /** | 559 | /** |
367 | * Contexts: | 560 | * Contexts: |
368 | * Statement returns EnumInterpretation | 561 | * AssertionOrDefinition.Assertion_1_0_0 returns Conjunction |
369 | * Interpretation returns EnumInterpretation | 562 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction |
370 | * CDInterpretation returns EnumInterpretation | 563 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Conjunction |
371 | * EnumInterpretation returns EnumInterpretation | 564 | * Expression returns Conjunction |
565 | * DisjunctiveExpression returns Conjunction | ||
566 | * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction | ||
567 | * DisjunctiveExpression.Case_1_1_0 returns Conjunction | ||
568 | * ConjunctiveExpression returns Conjunction | ||
569 | * ConjunctiveExpression.Conjunction_1_0 returns Conjunction | ||
570 | * ComparisonExpression returns Conjunction | ||
571 | * ComparisonExpression.Comparison_1_0 returns Conjunction | ||
572 | * AdditiveExpression returns Conjunction | ||
573 | * AdditiveExpression.BinaryExpression_1_0 returns Conjunction | ||
574 | * MultiplicativeExpression returns Conjunction | ||
575 | * MultiplicativeExpression.BinaryExpression_1_0 returns Conjunction | ||
576 | * ExponentialExpression returns Conjunction | ||
577 | * ExponentialExpression.BinaryExpression_1_0 returns Conjunction | ||
578 | * UnaryExpression returns Conjunction | ||
579 | * AggregationExpression returns Conjunction | ||
580 | * AtomicExpression returns Conjunction | ||
372 | * | 581 | * |
373 | * Constraint: | 582 | * Constraint: |
374 | * (Symbol=ModelSymbol objects+=NamedObject+) | 583 | * (children+=ConjunctiveExpression_Conjunction_1_0 children+=ComparisonExpression+) |
375 | */ | 584 | */ |
376 | protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) { | 585 | protected void sequence_ConjunctiveExpression(ISerializationContext context, Conjunction semanticObject) { |
377 | genericSequencer.createSequence(context, semanticObject); | 586 | genericSequencer.createSequence(context, semanticObject); |
378 | } | 587 | } |
379 | 588 | ||
380 | 589 | ||
381 | /** | 590 | /** |
382 | * Contexts: | 591 | * Contexts: |
383 | * Symbol returns EqualsSymbol | 592 | * AssertionOrDefinition.Assertion_1_0_0 returns Count |
384 | * PartialitySymbol returns EqualsSymbol | 593 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Count |
385 | * EqualsSymbol returns EqualsSymbol | 594 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Count |
595 | * Expression returns Count | ||
596 | * DisjunctiveExpression returns Count | ||
597 | * DisjunctiveExpression.Disjunction_1_0_0 returns Count | ||
598 | * DisjunctiveExpression.Case_1_1_0 returns Count | ||
599 | * ConjunctiveExpression returns Count | ||
600 | * ConjunctiveExpression.Conjunction_1_0 returns Count | ||
601 | * ComparisonExpression returns Count | ||
602 | * ComparisonExpression.Comparison_1_0 returns Count | ||
603 | * AdditiveExpression returns Count | ||
604 | * AdditiveExpression.BinaryExpression_1_0 returns Count | ||
605 | * MultiplicativeExpression returns Count | ||
606 | * MultiplicativeExpression.BinaryExpression_1_0 returns Count | ||
607 | * ExponentialExpression returns Count | ||
608 | * ExponentialExpression.BinaryExpression_1_0 returns Count | ||
609 | * UnaryExpression returns Count | ||
610 | * AggregationExpression returns Count | ||
611 | * Count returns Count | ||
612 | * AtomicExpression returns Count | ||
386 | * | 613 | * |
387 | * Constraint: | 614 | * Constraint: |
388 | * {EqualsSymbol} | 615 | * body=Expression |
389 | */ | 616 | */ |
390 | protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) { | 617 | protected void sequence_Count(ISerializationContext context, Count semanticObject) { |
391 | genericSequencer.createSequence(context, semanticObject); | 618 | if (errorAcceptor != null) { |
619 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY) == ValueTransient.YES) | ||
620 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY)); | ||
621 | } | ||
622 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
623 | feeder.accept(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
624 | feeder.finish(); | ||
392 | } | 625 | } |
393 | 626 | ||
394 | 627 | ||
395 | /** | 628 | /** |
396 | * Contexts: | 629 | * Contexts: |
397 | * Symbol returns ExistSymbol | 630 | * Statement returns DefaultDefinition |
398 | * PartialitySymbol returns ExistSymbol | 631 | * DefaultDefinition returns DefaultDefinition |
399 | * ExistSymbol returns ExistSymbol | ||
400 | * | 632 | * |
401 | * Constraint: | 633 | * Constraint: |
402 | * {ExistSymbol} | 634 | * (head=Call range=Expression) |
403 | */ | 635 | */ |
404 | protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) { | 636 | protected void sequence_DefaultDefinition(ISerializationContext context, DefaultDefinition semanticObject) { |
405 | genericSequencer.createSequence(context, semanticObject); | 637 | if (errorAcceptor != null) { |
638 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD) == ValueTransient.YES) | ||
639 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD)); | ||
640 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE) == ValueTransient.YES) | ||
641 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE)); | ||
642 | } | ||
643 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
644 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | ||
645 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0(), semanticObject.getRange()); | ||
646 | feeder.finish(); | ||
406 | } | 647 | } |
407 | 648 | ||
408 | 649 | ||
409 | /** | 650 | /** |
410 | * Contexts: | 651 | * Contexts: |
411 | * FieldRelationInterpretation returns FieldRelationInterpretation | 652 | * AssertionOrDefinition.Assertion_1_0_0 returns Disjunction |
653 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction | ||
654 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Disjunction | ||
655 | * Expression returns Disjunction | ||
656 | * DisjunctiveExpression returns Disjunction | ||
657 | * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction | ||
658 | * DisjunctiveExpression.Case_1_1_0 returns Disjunction | ||
659 | * ConjunctiveExpression returns Disjunction | ||
660 | * ConjunctiveExpression.Conjunction_1_0 returns Disjunction | ||
661 | * ComparisonExpression returns Disjunction | ||
662 | * ComparisonExpression.Comparison_1_0 returns Disjunction | ||
663 | * AdditiveExpression returns Disjunction | ||
664 | * AdditiveExpression.BinaryExpression_1_0 returns Disjunction | ||
665 | * MultiplicativeExpression returns Disjunction | ||
666 | * MultiplicativeExpression.BinaryExpression_1_0 returns Disjunction | ||
667 | * ExponentialExpression returns Disjunction | ||
668 | * ExponentialExpression.BinaryExpression_1_0 returns Disjunction | ||
669 | * UnaryExpression returns Disjunction | ||
670 | * AggregationExpression returns Disjunction | ||
671 | * AtomicExpression returns Disjunction | ||
412 | * | 672 | * |
413 | * Constraint: | 673 | * Constraint: |
414 | * (containment?='containment'? symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol) | 674 | * (children+=DisjunctiveExpression_Disjunction_1_0_0 children+=ConjunctiveExpression+) |
415 | */ | 675 | */ |
416 | protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) { | 676 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Disjunction semanticObject) { |
417 | genericSequencer.createSequence(context, semanticObject); | 677 | genericSequencer.createSequence(context, semanticObject); |
418 | } | 678 | } |
419 | 679 | ||
420 | 680 | ||
421 | /** | 681 | /** |
422 | * Contexts: | 682 | * Contexts: |
423 | * Statement returns GlobalRelationInterpretation | 683 | * AssertionOrDefinition.Assertion_1_0_0 returns Switch |
424 | * Interpretation returns GlobalRelationInterpretation | 684 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch |
425 | * CDInterpretation returns GlobalRelationInterpretation | 685 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Switch |
426 | * GlobalRelationInterpretation returns GlobalRelationInterpretation | 686 | * Expression returns Switch |
687 | * DisjunctiveExpression returns Switch | ||
688 | * DisjunctiveExpression.Disjunction_1_0_0 returns Switch | ||
689 | * DisjunctiveExpression.Case_1_1_0 returns Switch | ||
690 | * ConjunctiveExpression returns Switch | ||
691 | * ConjunctiveExpression.Conjunction_1_0 returns Switch | ||
692 | * ComparisonExpression returns Switch | ||
693 | * ComparisonExpression.Comparison_1_0 returns Switch | ||
694 | * AdditiveExpression returns Switch | ||
695 | * AdditiveExpression.BinaryExpression_1_0 returns Switch | ||
696 | * MultiplicativeExpression returns Switch | ||
697 | * MultiplicativeExpression.BinaryExpression_1_0 returns Switch | ||
698 | * ExponentialExpression returns Switch | ||
699 | * ExponentialExpression.BinaryExpression_1_0 returns Switch | ||
700 | * UnaryExpression returns Switch | ||
701 | * AggregationExpression returns Switch | ||
702 | * AtomicExpression returns Switch | ||
427 | * | 703 | * |
428 | * Constraint: | 704 | * Constraint: |
429 | * ( | 705 | * (cases+=DisjunctiveExpression_Switch_1_1_3 cases+=Case*) |
430 | * containment?='containment'? | ||
431 | * symbol=ModelSymbol | ||
432 | * sourceMultiplicity=MultiplicityDefinition? | ||
433 | * source=Symbol | ||
434 | * targetMultiplicity=MultiplicityDefinition? | ||
435 | * target=Symbol | ||
436 | * ) | ||
437 | */ | 706 | */ |
438 | protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) { | 707 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Switch semanticObject) { |
439 | genericSequencer.createSequence(context, semanticObject); | 708 | genericSequencer.createSequence(context, semanticObject); |
440 | } | 709 | } |
441 | 710 | ||
442 | 711 | ||
443 | /** | 712 | /** |
444 | * Contexts: | 713 | * Contexts: |
445 | * ComplexObject returns IntObject | 714 | * DisjunctiveExpression.Switch_1_1_3 returns Case |
446 | * Object returns IntObject | ||
447 | * DataObject returns IntObject | ||
448 | * IntObject returns IntObject | ||
449 | * Literal returns IntObject | ||
450 | * | 715 | * |
451 | * Constraint: | 716 | * Constraint: |
452 | * value=INTLiteral | 717 | * (condition=DisjunctiveExpression_Case_1_1_0 body=ConjunctiveExpression) |
453 | */ | 718 | */ |
454 | protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) { | 719 | protected void sequence_DisjunctiveExpression_Switch_1_1_3(ISerializationContext context, Case semanticObject) { |
455 | if (errorAcceptor != null) { | 720 | if (errorAcceptor != null) { |
456 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES) | 721 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) |
457 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE)); | 722 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); |
723 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
724 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
458 | } | 725 | } |
459 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 726 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
460 | feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue()); | 727 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), semanticObject.getCondition()); |
728 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
461 | feeder.finish(); | 729 | feeder.finish(); |
462 | } | 730 | } |
463 | 731 | ||
464 | 732 | ||
465 | /** | 733 | /** |
466 | * Contexts: | 734 | * Contexts: |
467 | * Symbol returns IntegerSymbol | 735 | * AssertionOrDefinition.Assertion_1_0_0 returns EmptyIntervalLiteral |
468 | * DataSymbol returns IntegerSymbol | 736 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyIntervalLiteral |
469 | * IntegerSymbol returns IntegerSymbol | 737 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns EmptyIntervalLiteral |
738 | * Expression returns EmptyIntervalLiteral | ||
739 | * DisjunctiveExpression returns EmptyIntervalLiteral | ||
740 | * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyIntervalLiteral | ||
741 | * DisjunctiveExpression.Case_1_1_0 returns EmptyIntervalLiteral | ||
742 | * ConjunctiveExpression returns EmptyIntervalLiteral | ||
743 | * ConjunctiveExpression.Conjunction_1_0 returns EmptyIntervalLiteral | ||
744 | * ComparisonExpression returns EmptyIntervalLiteral | ||
745 | * ComparisonExpression.Comparison_1_0 returns EmptyIntervalLiteral | ||
746 | * AdditiveExpression returns EmptyIntervalLiteral | ||
747 | * AdditiveExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
748 | * MultiplicativeExpression returns EmptyIntervalLiteral | ||
749 | * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
750 | * ExponentialExpression returns EmptyIntervalLiteral | ||
751 | * ExponentialExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
752 | * UnaryExpression returns EmptyIntervalLiteral | ||
753 | * AggregationExpression returns EmptyIntervalLiteral | ||
754 | * AtomicExpression returns EmptyIntervalLiteral | ||
755 | * Literal returns EmptyIntervalLiteral | ||
756 | * EmptyIntervalLiteral returns EmptyIntervalLiteral | ||
470 | * | 757 | * |
471 | * Constraint: | 758 | * Constraint: |
472 | * {IntegerSymbol} | 759 | * {EmptyIntervalLiteral} |
473 | */ | 760 | */ |
474 | protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) { | 761 | protected void sequence_EmptyIntervalLiteral(ISerializationContext context, EmptyIntervalLiteral semanticObject) { |
475 | genericSequencer.createSequence(context, semanticObject); | 762 | genericSequencer.createSequence(context, semanticObject); |
476 | } | 763 | } |
477 | 764 | ||
478 | 765 | ||
479 | /** | 766 | /** |
480 | * Contexts: | 767 | * Contexts: |
481 | * Symbol returns ModelSymbol | 768 | * Multiplicity returns ExactMultiplicity |
482 | * ModelSymbol returns ModelSymbol | 769 | * ExactMultiplicity returns ExactMultiplicity |
483 | * | 770 | * |
484 | * Constraint: | 771 | * Constraint: |
485 | * name=ID | 772 | * multiplicity=UpperMultiplicty |
486 | */ | 773 | */ |
487 | protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) { | 774 | protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { |
488 | if (errorAcceptor != null) { | 775 | if (errorAcceptor != null) { |
489 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES) | 776 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY) == ValueTransient.YES) |
490 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME)); | 777 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY)); |
491 | } | 778 | } |
492 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 779 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
493 | feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 780 | feeder.accept(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0(), semanticObject.getMultiplicity()); |
494 | feeder.finish(); | 781 | feeder.finish(); |
495 | } | 782 | } |
496 | 783 | ||
497 | 784 | ||
498 | /** | 785 | /** |
499 | * Contexts: | 786 | * Contexts: |
500 | * MultiplicityDefinition returns MultiplicityDefinition | 787 | * Statement returns ExactScopeDefinition |
788 | * ScopeDefinition returns ExactScopeDefinition | ||
789 | * ExactScopeDefinition returns ExactScopeDefinition | ||
501 | * | 790 | * |
502 | * Constraint: | 791 | * Constraint: |
503 | * (lower=INT (upper=INT | unlimitedUpper?='*')) | 792 | * (type=[NamedElement|QualifiedName] exactScope=INT) |
504 | */ | 793 | */ |
505 | protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) { | 794 | protected void sequence_ExactScopeDefinition(ISerializationContext context, ExactScopeDefinition semanticObject) { |
506 | genericSequencer.createSequence(context, semanticObject); | 795 | if (errorAcceptor != null) { |
796 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE) == ValueTransient.YES) | ||
797 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE)); | ||
798 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE) == ValueTransient.YES) | ||
799 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE)); | ||
800 | } | ||
801 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
802 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE, false)); | ||
803 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0(), semanticObject.getExactScope()); | ||
804 | feeder.finish(); | ||
507 | } | 805 | } |
508 | 806 | ||
509 | 807 | ||
510 | /** | 808 | /** |
511 | * Contexts: | 809 | * Contexts: |
512 | * ComplexObject returns NamedObject | 810 | * Argument returns ExpressionArgument |
513 | * Object returns NamedObject | 811 | * ExpressionArgument returns ExpressionArgument |
514 | * NamedObject returns NamedObject | ||
515 | * Literal returns NamedObject | ||
516 | * | 812 | * |
517 | * Constraint: | 813 | * Constraint: |
518 | * name=ID | 814 | * body=ComparisonExpression |
519 | */ | 815 | */ |
520 | protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) { | 816 | protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) { |
521 | if (errorAcceptor != null) { | 817 | if (errorAcceptor != null) { |
522 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES) | 818 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY) == ValueTransient.YES) |
523 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME)); | 819 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY)); |
524 | } | 820 | } |
525 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 821 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
526 | feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); | 822 | feeder.accept(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0(), semanticObject.getBody()); |
527 | feeder.finish(); | 823 | feeder.finish(); |
528 | } | 824 | } |
529 | 825 | ||
530 | 826 | ||
531 | /** | 827 | /** |
532 | * Contexts: | 828 | * Contexts: |
533 | * Parameter returns Parameter | 829 | * Statement returns ExternMetricDefinition |
830 | * ExternMetricDefinition returns ExternMetricDefinition | ||
534 | * | 831 | * |
535 | * Constraint: | 832 | * Constraint: |
536 | * (variable=Variable type=Symbol?) | 833 | * (type=MetricType head=Call) |
537 | */ | 834 | */ |
538 | protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) { | 835 | protected void sequence_ExternMetricDefinition(ISerializationContext context, ExternMetricDefinition semanticObject) { |
539 | genericSequencer.createSequence(context, semanticObject); | 836 | if (errorAcceptor != null) { |
837 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE) == ValueTransient.YES) | ||
838 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE)); | ||
839 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD) == ValueTransient.YES) | ||
840 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD)); | ||
841 | } | ||
842 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
843 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0(), semanticObject.getType()); | ||
844 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0(), semanticObject.getHead()); | ||
845 | feeder.finish(); | ||
540 | } | 846 | } |
541 | 847 | ||
542 | 848 | ||
543 | /** | 849 | /** |
544 | * Contexts: | 850 | * Contexts: |
545 | * PatternBody returns PatternBody | 851 | * Statement returns ExternPredicateDefinition |
852 | * ExternPredicateDefinition returns ExternPredicateDefinition | ||
546 | * | 853 | * |
547 | * Constraint: | 854 | * Constraint: |
548 | * constraints+=Constraint* | 855 | * head=Call |
549 | */ | 856 | */ |
550 | protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) { | 857 | protected void sequence_ExternPredicateDefinition(ISerializationContext context, ExternPredicateDefinition semanticObject) { |
551 | genericSequencer.createSequence(context, semanticObject); | 858 | if (errorAcceptor != null) { |
859 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD) == ValueTransient.YES) | ||
860 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD)); | ||
861 | } | ||
862 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
863 | feeder.accept(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | ||
864 | feeder.finish(); | ||
865 | } | ||
866 | |||
867 | |||
868 | /** | ||
869 | * Contexts: | ||
870 | * AssertionOrDefinition.Assertion_1_0_0 returns IfElse | ||
871 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IfElse | ||
872 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns IfElse | ||
873 | * Expression returns IfElse | ||
874 | * IfElse returns IfElse | ||
875 | * DisjunctiveExpression returns IfElse | ||
876 | * DisjunctiveExpression.Disjunction_1_0_0 returns IfElse | ||
877 | * DisjunctiveExpression.Case_1_1_0 returns IfElse | ||
878 | * ConjunctiveExpression returns IfElse | ||
879 | * ConjunctiveExpression.Conjunction_1_0 returns IfElse | ||
880 | * ComparisonExpression returns IfElse | ||
881 | * ComparisonExpression.Comparison_1_0 returns IfElse | ||
882 | * AdditiveExpression returns IfElse | ||
883 | * AdditiveExpression.BinaryExpression_1_0 returns IfElse | ||
884 | * MultiplicativeExpression returns IfElse | ||
885 | * MultiplicativeExpression.BinaryExpression_1_0 returns IfElse | ||
886 | * ExponentialExpression returns IfElse | ||
887 | * ExponentialExpression.BinaryExpression_1_0 returns IfElse | ||
888 | * UnaryExpression returns IfElse | ||
889 | * AggregationExpression returns IfElse | ||
890 | * AtomicExpression returns IfElse | ||
891 | * | ||
892 | * Constraint: | ||
893 | * (condition=Expression then=Expression else=Expression) | ||
894 | */ | ||
895 | protected void sequence_IfElse(ISerializationContext context, IfElse semanticObject) { | ||
896 | if (errorAcceptor != null) { | ||
897 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION) == ValueTransient.YES) | ||
898 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION)); | ||
899 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN) == ValueTransient.YES) | ||
900 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN)); | ||
901 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE) == ValueTransient.YES) | ||
902 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE)); | ||
903 | } | ||
904 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
905 | feeder.accept(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition()); | ||
906 | feeder.accept(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen()); | ||
907 | feeder.accept(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse()); | ||
908 | feeder.finish(); | ||
552 | } | 909 | } |
553 | 910 | ||
554 | 911 | ||
555 | /** | 912 | /** |
556 | * Contexts: | 913 | * Contexts: |
557 | * Polarity returns Negative | 914 | * AssertionOrDefinition.Assertion_1_0_0 returns InfinityLiteral |
915 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral | ||
916 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns InfinityLiteral | ||
917 | * Expression returns InfinityLiteral | ||
918 | * DisjunctiveExpression returns InfinityLiteral | ||
919 | * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral | ||
920 | * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral | ||
921 | * ConjunctiveExpression returns InfinityLiteral | ||
922 | * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral | ||
923 | * ComparisonExpression returns InfinityLiteral | ||
924 | * ComparisonExpression.Comparison_1_0 returns InfinityLiteral | ||
925 | * AdditiveExpression returns InfinityLiteral | ||
926 | * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
927 | * MultiplicativeExpression returns InfinityLiteral | ||
928 | * MultiplicativeExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
929 | * ExponentialExpression returns InfinityLiteral | ||
930 | * ExponentialExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
931 | * UnaryExpression returns InfinityLiteral | ||
932 | * AggregationExpression returns InfinityLiteral | ||
933 | * AtomicExpression returns InfinityLiteral | ||
934 | * Literal returns InfinityLiteral | ||
935 | * InfinityLiteral returns InfinityLiteral | ||
558 | * | 936 | * |
559 | * Constraint: | 937 | * Constraint: |
560 | * {Negative} | 938 | * {InfinityLiteral} |
561 | */ | 939 | */ |
562 | protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) { | 940 | protected void sequence_InfinityLiteral(ISerializationContext context, InfinityLiteral semanticObject) { |
563 | genericSequencer.createSequence(context, semanticObject); | 941 | genericSequencer.createSequence(context, semanticObject); |
564 | } | 942 | } |
565 | 943 | ||
566 | 944 | ||
567 | /** | 945 | /** |
568 | * Contexts: | 946 | * Contexts: |
569 | * Polarity returns Positive | 947 | * AssertionOrDefinition.Assertion_1_0_0 returns Interval |
948 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval | ||
949 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Interval | ||
950 | * Expression returns Interval | ||
951 | * DisjunctiveExpression returns Interval | ||
952 | * DisjunctiveExpression.Disjunction_1_0_0 returns Interval | ||
953 | * DisjunctiveExpression.Case_1_1_0 returns Interval | ||
954 | * ConjunctiveExpression returns Interval | ||
955 | * ConjunctiveExpression.Conjunction_1_0 returns Interval | ||
956 | * ComparisonExpression returns Interval | ||
957 | * ComparisonExpression.Comparison_1_0 returns Interval | ||
958 | * AdditiveExpression returns Interval | ||
959 | * AdditiveExpression.BinaryExpression_1_0 returns Interval | ||
960 | * MultiplicativeExpression returns Interval | ||
961 | * MultiplicativeExpression.BinaryExpression_1_0 returns Interval | ||
962 | * ExponentialExpression returns Interval | ||
963 | * ExponentialExpression.BinaryExpression_1_0 returns Interval | ||
964 | * UnaryExpression returns Interval | ||
965 | * AggregationExpression returns Interval | ||
966 | * AtomicExpression returns Interval | ||
967 | * Interval returns Interval | ||
570 | * | 968 | * |
571 | * Constraint: | 969 | * Constraint: |
572 | * {Positive} | 970 | * (lowerBound=Expression upperBound=Expression) |
573 | */ | 971 | */ |
574 | protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) { | 972 | protected void sequence_Interval(ISerializationContext context, Interval semanticObject) { |
973 | if (errorAcceptor != null) { | ||
974 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND) == ValueTransient.YES) | ||
975 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND)); | ||
976 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND) == ValueTransient.YES) | ||
977 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND)); | ||
978 | } | ||
979 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
980 | feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0(), semanticObject.getLowerBound()); | ||
981 | feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
982 | feeder.finish(); | ||
983 | } | ||
984 | |||
985 | |||
986 | /** | ||
987 | * Contexts: | ||
988 | * AssertionOrDefinition.Assertion_1_0_0 returns LogicLiteral | ||
989 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral | ||
990 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns LogicLiteral | ||
991 | * Expression returns LogicLiteral | ||
992 | * DisjunctiveExpression returns LogicLiteral | ||
993 | * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral | ||
994 | * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral | ||
995 | * ConjunctiveExpression returns LogicLiteral | ||
996 | * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral | ||
997 | * ComparisonExpression returns LogicLiteral | ||
998 | * ComparisonExpression.Comparison_1_0 returns LogicLiteral | ||
999 | * AdditiveExpression returns LogicLiteral | ||
1000 | * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1001 | * MultiplicativeExpression returns LogicLiteral | ||
1002 | * MultiplicativeExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1003 | * ExponentialExpression returns LogicLiteral | ||
1004 | * ExponentialExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1005 | * UnaryExpression returns LogicLiteral | ||
1006 | * AggregationExpression returns LogicLiteral | ||
1007 | * AtomicExpression returns LogicLiteral | ||
1008 | * Literal returns LogicLiteral | ||
1009 | * LogicLiteral returns LogicLiteral | ||
1010 | * | ||
1011 | * Constraint: | ||
1012 | * value=LogicValue | ||
1013 | */ | ||
1014 | protected void sequence_LogicLiteral(ISerializationContext context, LogicLiteral semanticObject) { | ||
1015 | if (errorAcceptor != null) { | ||
1016 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE) == ValueTransient.YES) | ||
1017 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE)); | ||
1018 | } | ||
1019 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1020 | feeder.accept(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0(), semanticObject.getValue()); | ||
1021 | feeder.finish(); | ||
1022 | } | ||
1023 | |||
1024 | |||
1025 | /** | ||
1026 | * Contexts: | ||
1027 | * Statement returns LowerBoundedScopeDefinition | ||
1028 | * ScopeDefinition returns LowerBoundedScopeDefinition | ||
1029 | * LowerBoundedScopeDefinition returns LowerBoundedScopeDefinition | ||
1030 | * | ||
1031 | * Constraint: | ||
1032 | * ((lowerBound=INT type=[NamedElement|QualifiedName]) | (type=[NamedElement|QualifiedName] lowerBound=INT)) | ||
1033 | */ | ||
1034 | protected void sequence_LowerBoundedScopeDefinition(ISerializationContext context, LowerBoundedScopeDefinition semanticObject) { | ||
575 | genericSequencer.createSequence(context, semanticObject); | 1035 | genericSequencer.createSequence(context, semanticObject); |
576 | } | 1036 | } |
577 | 1037 | ||
578 | 1038 | ||
579 | /** | 1039 | /** |
580 | * Contexts: | 1040 | * Contexts: |
581 | * Statement returns Predicate | 1041 | * Multiplicity returns ManyMultiplicity |
582 | * Predicate returns Predicate | 1042 | * ManyMultiplicity returns ManyMultiplicity |
583 | * | 1043 | * |
584 | * Constraint: | 1044 | * Constraint: |
585 | * (isError?='error'? symbol=ModelSymbol (parameters+=Parameter parameters+=Parameter*)? (bodies+=PatternBody bodies+=PatternBody*)?) | 1045 | * {ManyMultiplicity} |
586 | */ | 1046 | */ |
587 | protected void sequence_Predicate(ISerializationContext context, Predicate semanticObject) { | 1047 | protected void sequence_ManyMultiplicity(ISerializationContext context, ManyMultiplicity semanticObject) { |
588 | genericSequencer.createSequence(context, semanticObject); | 1048 | genericSequencer.createSequence(context, semanticObject); |
589 | } | 1049 | } |
590 | 1050 | ||
591 | 1051 | ||
592 | /** | 1052 | /** |
593 | * Contexts: | 1053 | * Contexts: |
594 | * Problem returns Problem | 1054 | * MemberDefinition returns MemberDefinition |
595 | * | 1055 | * |
596 | * Constraint: | 1056 | * Constraint: |
597 | * statements+=Statement+ | 1057 | * (containment?='contains'? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID opposite=[NamedElement|QualifiedName]?) |
598 | */ | 1058 | */ |
599 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { | 1059 | protected void sequence_MemberDefinition(ISerializationContext context, MemberDefinition semanticObject) { |
600 | genericSequencer.createSequence(context, semanticObject); | 1060 | genericSequencer.createSequence(context, semanticObject); |
601 | } | 1061 | } |
602 | 1062 | ||
603 | 1063 | ||
604 | /** | 1064 | /** |
605 | * Contexts: | 1065 | * Contexts: |
606 | * ComplexObject returns RealObject | 1066 | * MetricDefinition returns MetricDefinition |
607 | * Object returns RealObject | ||
608 | * DataObject returns RealObject | ||
609 | * RealObject returns RealObject | ||
610 | * Literal returns RealObject | ||
611 | * | 1067 | * |
612 | * Constraint: | 1068 | * Constraint: |
613 | * value=REALLiteral | 1069 | * (type=MetricType head=Expression body=Expression) |
614 | */ | 1070 | */ |
615 | protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) { | 1071 | protected void sequence_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
616 | if (errorAcceptor != null) { | 1072 | if (errorAcceptor != null) { |
617 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES) | 1073 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE) == ValueTransient.YES) |
618 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE)); | 1074 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE)); |
1075 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) | ||
1076 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); | ||
1077 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | ||
1078 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | ||
619 | } | 1079 | } |
620 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1080 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
621 | feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue()); | 1081 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0(), semanticObject.getType()); |
1082 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0(), semanticObject.getHead()); | ||
1083 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
622 | feeder.finish(); | 1084 | feeder.finish(); |
623 | } | 1085 | } |
624 | 1086 | ||
625 | 1087 | ||
626 | /** | 1088 | /** |
627 | * Contexts: | 1089 | * Contexts: |
628 | * Symbol returns RealSymbol | 1090 | * NamedElement returns NamedElement |
629 | * DataSymbol returns RealSymbol | ||
630 | * RealSymbol returns RealSymbol | ||
631 | * | 1091 | * |
632 | * Constraint: | 1092 | * Constraint: |
633 | * {RealSymbol} | 1093 | * name=QualifiedName |
634 | */ | 1094 | */ |
635 | protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) { | 1095 | protected void sequence_NamedElement(ISerializationContext context, NamedElement semanticObject) { |
636 | genericSequencer.createSequence(context, semanticObject); | 1096 | if (errorAcceptor != null) { |
1097 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME) == ValueTransient.YES) | ||
1098 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME)); | ||
1099 | } | ||
1100 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1101 | feeder.accept(grammarAccess.getNamedElementAccess().getNameQualifiedNameParserRuleCall_0(), semanticObject.getName()); | ||
1102 | feeder.finish(); | ||
637 | } | 1103 | } |
638 | 1104 | ||
639 | 1105 | ||
640 | /** | 1106 | /** |
641 | * Contexts: | 1107 | * Contexts: |
642 | * ComplexObject returns StringObject | 1108 | * AssertionOrDefinition.Assertion_1_0_0 returns NumericLiteral |
643 | * Object returns StringObject | 1109 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns NumericLiteral |
644 | * DataObject returns StringObject | 1110 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns NumericLiteral |
645 | * StringObject returns StringObject | 1111 | * Expression returns NumericLiteral |
646 | * Literal returns StringObject | 1112 | * DisjunctiveExpression returns NumericLiteral |
1113 | * DisjunctiveExpression.Disjunction_1_0_0 returns NumericLiteral | ||
1114 | * DisjunctiveExpression.Case_1_1_0 returns NumericLiteral | ||
1115 | * ConjunctiveExpression returns NumericLiteral | ||
1116 | * ConjunctiveExpression.Conjunction_1_0 returns NumericLiteral | ||
1117 | * ComparisonExpression returns NumericLiteral | ||
1118 | * ComparisonExpression.Comparison_1_0 returns NumericLiteral | ||
1119 | * AdditiveExpression returns NumericLiteral | ||
1120 | * AdditiveExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1121 | * MultiplicativeExpression returns NumericLiteral | ||
1122 | * MultiplicativeExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1123 | * ExponentialExpression returns NumericLiteral | ||
1124 | * ExponentialExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1125 | * UnaryExpression returns NumericLiteral | ||
1126 | * AggregationExpression returns NumericLiteral | ||
1127 | * AtomicExpression returns NumericLiteral | ||
1128 | * Literal returns NumericLiteral | ||
1129 | * NumericLiteral returns NumericLiteral | ||
647 | * | 1130 | * |
648 | * Constraint: | 1131 | * Constraint: |
649 | * value=STRING | 1132 | * value=Real |
650 | */ | 1133 | */ |
651 | protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) { | 1134 | protected void sequence_NumericLiteral(ISerializationContext context, NumericLiteral semanticObject) { |
652 | if (errorAcceptor != null) { | 1135 | if (errorAcceptor != null) { |
653 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES) | 1136 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE) == ValueTransient.YES) |
654 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE)); | 1137 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE)); |
655 | } | 1138 | } |
656 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1139 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
657 | feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); | 1140 | feeder.accept(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue()); |
658 | feeder.finish(); | 1141 | feeder.finish(); |
659 | } | 1142 | } |
660 | 1143 | ||
661 | 1144 | ||
662 | /** | 1145 | /** |
663 | * Contexts: | 1146 | * Contexts: |
664 | * Symbol returns StringSymbol | 1147 | * Statement returns ObjectiveDefinition |
665 | * DataSymbol returns StringSymbol | 1148 | * ObjectiveDefinition returns ObjectiveDefinition |
666 | * StringSymbol returns StringSymbol | ||
667 | * | 1149 | * |
668 | * Constraint: | 1150 | * Constraint: |
669 | * {StringSymbol} | 1151 | * (kind=ObjectiveKind objective=Expression) |
670 | */ | 1152 | */ |
671 | protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) { | 1153 | protected void sequence_ObjectiveDefinition(ISerializationContext context, ObjectiveDefinition semanticObject) { |
672 | genericSequencer.createSequence(context, semanticObject); | 1154 | if (errorAcceptor != null) { |
1155 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND) == ValueTransient.YES) | ||
1156 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND)); | ||
1157 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE) == ValueTransient.YES) | ||
1158 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE)); | ||
1159 | } | ||
1160 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1161 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
1162 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective()); | ||
1163 | feeder.finish(); | ||
673 | } | 1164 | } |
674 | 1165 | ||
675 | 1166 | ||
676 | /** | 1167 | /** |
677 | * Contexts: | 1168 | * Contexts: |
678 | * TruthValue returns Error | 1169 | * PredicateDefinition returns PredicateDefinition |
679 | * | 1170 | * |
680 | * Constraint: | 1171 | * Constraint: |
681 | * {Error} | 1172 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) |
682 | */ | 1173 | */ |
683 | protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) { | 1174 | protected void sequence_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
684 | genericSequencer.createSequence(context, semanticObject); | 1175 | genericSequencer.createSequence(context, semanticObject); |
685 | } | 1176 | } |
686 | 1177 | ||
687 | 1178 | ||
688 | /** | 1179 | /** |
689 | * Contexts: | 1180 | * Contexts: |
690 | * TruthValue returns False | 1181 | * Problem returns Problem |
691 | * | 1182 | * |
692 | * Constraint: | 1183 | * Constraint: |
693 | * {False} | 1184 | * statements+=Statement+ |
694 | */ | 1185 | */ |
695 | protected void sequence_TruthValue(ISerializationContext context, False semanticObject) { | 1186 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { |
696 | genericSequencer.createSequence(context, semanticObject); | 1187 | genericSequencer.createSequence(context, semanticObject); |
697 | } | 1188 | } |
698 | 1189 | ||
699 | 1190 | ||
700 | /** | 1191 | /** |
701 | * Contexts: | 1192 | * Contexts: |
702 | * TruthValue returns True | 1193 | * AssertionOrDefinition.Assertion_1_0_0 returns Reference |
1194 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference | ||
1195 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Reference | ||
1196 | * Expression returns Reference | ||
1197 | * DisjunctiveExpression returns Reference | ||
1198 | * DisjunctiveExpression.Disjunction_1_0_0 returns Reference | ||
1199 | * DisjunctiveExpression.Case_1_1_0 returns Reference | ||
1200 | * ConjunctiveExpression returns Reference | ||
1201 | * ConjunctiveExpression.Conjunction_1_0 returns Reference | ||
1202 | * ComparisonExpression returns Reference | ||
1203 | * ComparisonExpression.Comparison_1_0 returns Reference | ||
1204 | * AdditiveExpression returns Reference | ||
1205 | * AdditiveExpression.BinaryExpression_1_0 returns Reference | ||
1206 | * MultiplicativeExpression returns Reference | ||
1207 | * MultiplicativeExpression.BinaryExpression_1_0 returns Reference | ||
1208 | * ExponentialExpression returns Reference | ||
1209 | * ExponentialExpression.BinaryExpression_1_0 returns Reference | ||
1210 | * UnaryExpression returns Reference | ||
1211 | * AggregationExpression returns Reference | ||
1212 | * AtomicExpression returns Reference | ||
1213 | * Reference returns Reference | ||
703 | * | 1214 | * |
704 | * Constraint: | 1215 | * Constraint: |
705 | * {True} | 1216 | * referred=[NamedElement|QualifiedName] |
706 | */ | 1217 | */ |
707 | protected void sequence_TruthValue(ISerializationContext context, True semanticObject) { | 1218 | protected void sequence_Reference(ISerializationContext context, Reference semanticObject) { |
708 | genericSequencer.createSequence(context, semanticObject); | 1219 | if (errorAcceptor != null) { |
1220 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED) == ValueTransient.YES) | ||
1221 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED)); | ||
1222 | } | ||
1223 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1224 | feeder.accept(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.REFERENCE__REFERRED, false)); | ||
1225 | feeder.finish(); | ||
709 | } | 1226 | } |
710 | 1227 | ||
711 | 1228 | ||
712 | /** | 1229 | /** |
713 | * Contexts: | 1230 | * Contexts: |
714 | * TruthValue returns Unknown | 1231 | * Argument returns StarArgument |
1232 | * StarArgument returns StarArgument | ||
715 | * | 1233 | * |
716 | * Constraint: | 1234 | * Constraint: |
717 | * {Unknown} | 1235 | * {StarArgument} |
718 | */ | 1236 | */ |
719 | protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) { | 1237 | protected void sequence_StarArgument(ISerializationContext context, StarArgument semanticObject) { |
720 | genericSequencer.createSequence(context, semanticObject); | 1238 | genericSequencer.createSequence(context, semanticObject); |
721 | } | 1239 | } |
722 | 1240 | ||
723 | 1241 | ||
724 | /** | 1242 | /** |
725 | * Contexts: | 1243 | * Contexts: |
726 | * ComplexObject returns UnnamedObject | 1244 | * AssertionOrDefinition.Assertion_1_0_0 returns StringLiteral |
727 | * Object returns UnnamedObject | 1245 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral |
728 | * UnnamedObject returns UnnamedObject | 1246 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns StringLiteral |
1247 | * Expression returns StringLiteral | ||
1248 | * DisjunctiveExpression returns StringLiteral | ||
1249 | * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral | ||
1250 | * DisjunctiveExpression.Case_1_1_0 returns StringLiteral | ||
1251 | * ConjunctiveExpression returns StringLiteral | ||
1252 | * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral | ||
1253 | * ComparisonExpression returns StringLiteral | ||
1254 | * ComparisonExpression.Comparison_1_0 returns StringLiteral | ||
1255 | * AdditiveExpression returns StringLiteral | ||
1256 | * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral | ||
1257 | * MultiplicativeExpression returns StringLiteral | ||
1258 | * MultiplicativeExpression.BinaryExpression_1_0 returns StringLiteral | ||
1259 | * ExponentialExpression returns StringLiteral | ||
1260 | * ExponentialExpression.BinaryExpression_1_0 returns StringLiteral | ||
1261 | * UnaryExpression returns StringLiteral | ||
1262 | * AggregationExpression returns StringLiteral | ||
1263 | * AtomicExpression returns StringLiteral | ||
1264 | * Literal returns StringLiteral | ||
1265 | * StringLiteral returns StringLiteral | ||
1266 | * | ||
1267 | * Constraint: | ||
1268 | * value=STRING | ||
1269 | */ | ||
1270 | protected void sequence_StringLiteral(ISerializationContext context, StringLiteral semanticObject) { | ||
1271 | if (errorAcceptor != null) { | ||
1272 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES) | ||
1273 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE)); | ||
1274 | } | ||
1275 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1276 | feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); | ||
1277 | feeder.finish(); | ||
1278 | } | ||
1279 | |||
1280 | |||
1281 | /** | ||
1282 | * Contexts: | ||
1283 | * Argument returns TypedArgument | ||
1284 | * TypedArgument returns TypedArgument | ||
1285 | * | ||
1286 | * Constraint: | ||
1287 | * (type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName]) | ||
1288 | */ | ||
1289 | protected void sequence_TypedArgument(ISerializationContext context, TypedArgument semanticObject) { | ||
1290 | if (errorAcceptor != null) { | ||
1291 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE) == ValueTransient.YES) | ||
1292 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE)); | ||
1293 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE) == ValueTransient.YES) | ||
1294 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE)); | ||
1295 | } | ||
1296 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1297 | feeder.accept(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE, false)); | ||
1298 | feeder.accept(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE, false)); | ||
1299 | feeder.finish(); | ||
1300 | } | ||
1301 | |||
1302 | |||
1303 | /** | ||
1304 | * Contexts: | ||
1305 | * Argument returns TypedStarArgument | ||
1306 | * TypedStarArgument returns TypedStarArgument | ||
1307 | * | ||
1308 | * Constraint: | ||
1309 | * type=[NamedElement|QualifiedName] | ||
1310 | */ | ||
1311 | protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) { | ||
1312 | if (errorAcceptor != null) { | ||
1313 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE) == ValueTransient.YES) | ||
1314 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE)); | ||
1315 | } | ||
1316 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1317 | feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE, false)); | ||
1318 | feeder.finish(); | ||
1319 | } | ||
1320 | |||
1321 | |||
1322 | /** | ||
1323 | * Contexts: | ||
1324 | * AssertionOrDefinition.Assertion_1_0_0 returns UnaryExpression | ||
1325 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression | ||
1326 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns UnaryExpression | ||
1327 | * Expression returns UnaryExpression | ||
1328 | * DisjunctiveExpression returns UnaryExpression | ||
1329 | * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression | ||
1330 | * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression | ||
1331 | * ConjunctiveExpression returns UnaryExpression | ||
1332 | * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression | ||
1333 | * ComparisonExpression returns UnaryExpression | ||
1334 | * ComparisonExpression.Comparison_1_0 returns UnaryExpression | ||
1335 | * AdditiveExpression returns UnaryExpression | ||
1336 | * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1337 | * MultiplicativeExpression returns UnaryExpression | ||
1338 | * MultiplicativeExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1339 | * ExponentialExpression returns UnaryExpression | ||
1340 | * ExponentialExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1341 | * UnaryExpression returns UnaryExpression | ||
1342 | * AggregationExpression returns UnaryExpression | ||
1343 | * AtomicExpression returns UnaryExpression | ||
729 | * | 1344 | * |
730 | * Constraint: | 1345 | * Constraint: |
731 | * name=ID | 1346 | * (op=UnaryOp body=AggregationExpression) |
732 | */ | 1347 | */ |
733 | protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) { | 1348 | protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) { |
734 | if (errorAcceptor != null) { | 1349 | if (errorAcceptor != null) { |
735 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES) | 1350 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP) == ValueTransient.YES) |
736 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME)); | 1351 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP)); |
1352 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY) == ValueTransient.YES) | ||
1353 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY)); | ||
737 | } | 1354 | } |
738 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1355 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
739 | feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 1356 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0(), semanticObject.getOp()); |
1357 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0(), semanticObject.getBody()); | ||
740 | feeder.finish(); | 1358 | feeder.finish(); |
741 | } | 1359 | } |
742 | 1360 | ||
743 | 1361 | ||
744 | /** | 1362 | /** |
745 | * Contexts: | 1363 | * Contexts: |
746 | * Literal returns Variable | 1364 | * Statement returns UnnamedErrorPrediateDefinition |
747 | * Variable returns Variable | 1365 | * UnnamedErrorPrediateDefinition returns UnnamedErrorPrediateDefinition |
748 | * | 1366 | * |
749 | * Constraint: | 1367 | * Constraint: |
750 | * name=ID | 1368 | * (argumentList=ArgumentList body=Expression) |
751 | */ | 1369 | */ |
752 | protected void sequence_Variable(ISerializationContext context, Variable semanticObject) { | 1370 | protected void sequence_UnnamedErrorPrediateDefinition(ISerializationContext context, UnnamedErrorPrediateDefinition semanticObject) { |
753 | if (errorAcceptor != null) { | 1371 | if (errorAcceptor != null) { |
754 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES) | 1372 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES) |
755 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME)); | 1373 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST)); |
1374 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY) == ValueTransient.YES) | ||
1375 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY)); | ||
756 | } | 1376 | } |
757 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1377 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
758 | feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 1378 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); |
1379 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
759 | feeder.finish(); | 1380 | feeder.finish(); |
760 | } | 1381 | } |
761 | 1382 | ||