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 | 1375 |
1 files changed, 737 insertions, 638 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 dc93975f..49326024 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 | |||
@@ -10,52 +10,58 @@ 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.Aggregation; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; |
12 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; |
13 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; | ||
14 | import org.eclipse.viatra.solver.language.solverLanguage.Attribute; | ||
13 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; |
14 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; |
15 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition; | 17 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScope; |
16 | import org.eclipse.viatra.solver.language.solverLanguage.Call; | 18 | import org.eclipse.viatra.solver.language.solverLanguage.Call; |
17 | import org.eclipse.viatra.solver.language.solverLanguage.Case; | 19 | import org.eclipse.viatra.solver.language.solverLanguage.Case; |
18 | import org.eclipse.viatra.solver.language.solverLanguage.CastExpression; | 20 | import org.eclipse.viatra.solver.language.solverLanguage.CastExpression; |
19 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition; | 21 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDeclaration; |
20 | import org.eclipse.viatra.solver.language.solverLanguage.Comparison; | 22 | import org.eclipse.viatra.solver.language.solverLanguage.ConditionalExpression; |
21 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; | 23 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; |
22 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition; | 24 | import org.eclipse.viatra.solver.language.solverLanguage.Count; |
25 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultAssertion; | ||
23 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; | 26 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; |
24 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral; | 27 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyLiteral; |
28 | import org.eclipse.viatra.solver.language.solverLanguage.EnumDeclaration; | ||
29 | import org.eclipse.viatra.solver.language.solverLanguage.EnumLiteral; | ||
25 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; | 30 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; |
26 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition; | 31 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScope; |
27 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; | 32 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; |
28 | import org.eclipse.viatra.solver.language.solverLanguage.ExternAggregatorDefinition; | 33 | import org.eclipse.viatra.solver.language.solverLanguage.ExternAggregationOperatorDeclaration; |
29 | import org.eclipse.viatra.solver.language.solverLanguage.ExternDatatypeDefinition; | 34 | import org.eclipse.viatra.solver.language.solverLanguage.ExternDatatypeDeclaration; |
30 | import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition; | 35 | import org.eclipse.viatra.solver.language.solverLanguage.ExternFunctionDeclaration; |
31 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition; | 36 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDeclaration; |
32 | import org.eclipse.viatra.solver.language.solverLanguage.IfElse; | 37 | import org.eclipse.viatra.solver.language.solverLanguage.Field; |
38 | import org.eclipse.viatra.solver.language.solverLanguage.Forall; | ||
39 | import org.eclipse.viatra.solver.language.solverLanguage.FunctionDefinition; | ||
33 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; | 40 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; |
34 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | 41 | import org.eclipse.viatra.solver.language.solverLanguage.IntLiteral; |
35 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; | 42 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; |
36 | import org.eclipse.viatra.solver.language.solverLanguage.Let; | ||
37 | import org.eclipse.viatra.solver.language.solverLanguage.LetBinding; | 43 | import org.eclipse.viatra.solver.language.solverLanguage.LetBinding; |
38 | import org.eclipse.viatra.solver.language.solverLanguage.LocalVariables; | 44 | import org.eclipse.viatra.solver.language.solverLanguage.LetExpression; |
39 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; | 45 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; |
40 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition; | 46 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScope; |
41 | import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity; | 47 | import org.eclipse.viatra.solver.language.solverLanguage.NamespaceImport; |
42 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; | 48 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDeclaration; |
43 | import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition; | 49 | import org.eclipse.viatra.solver.language.solverLanguage.PathComponent; |
44 | import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral; | ||
45 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition; | ||
46 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | 50 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; |
47 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | 51 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; |
48 | import org.eclipse.viatra.solver.language.solverLanguage.QuantifiedExpression; | 52 | import org.eclipse.viatra.solver.language.solverLanguage.RealLiteral; |
49 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; | 53 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; |
50 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 54 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
51 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; | 55 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; |
52 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; | 56 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; |
53 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; | 57 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; |
54 | import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument; | 58 | import org.eclipse.viatra.solver.language.solverLanguage.TypeReference; |
55 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; | 59 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; |
60 | import org.eclipse.viatra.solver.language.solverLanguage.TypedVariableArgument; | ||
56 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; | 61 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; |
57 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition; | 62 | import org.eclipse.viatra.solver.language.solverLanguage.UnboundedMultiplicity; |
58 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | 63 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPredicateDefintion; |
64 | import org.eclipse.viatra.solver.language.solverLanguage.UriImport; | ||
59 | import org.eclipse.xtext.Action; | 65 | import org.eclipse.xtext.Action; |
60 | import org.eclipse.xtext.Parameter; | 66 | import org.eclipse.xtext.Parameter; |
61 | import org.eclipse.xtext.ParserRule; | 67 | import org.eclipse.xtext.ParserRule; |
@@ -84,14 +90,20 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
84 | case SolverLanguagePackage.ARGUMENT_LIST: | 90 | case SolverLanguagePackage.ARGUMENT_LIST: |
85 | sequence_ArgumentList(context, (ArgumentList) semanticObject); | 91 | sequence_ArgumentList(context, (ArgumentList) semanticObject); |
86 | return; | 92 | return; |
93 | case SolverLanguagePackage.ASSERTION: | ||
94 | sequence_AssertionOrDefinition(context, (Assertion) semanticObject); | ||
95 | return; | ||
96 | case SolverLanguagePackage.ATTRIBUTE: | ||
97 | sequence_Attribute(context, (Attribute) semanticObject); | ||
98 | return; | ||
87 | case SolverLanguagePackage.BINARY_EXPRESSION: | 99 | case SolverLanguagePackage.BINARY_EXPRESSION: |
88 | sequence_AdditiveExpression_ExponentialExpression_ImplicationExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject); | 100 | sequence_AdditiveExpression_ComparisonExpression_ExponentialExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject); |
89 | return; | 101 | return; |
90 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: | 102 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: |
91 | sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject); | 103 | sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject); |
92 | return; | 104 | return; |
93 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: | 105 | case SolverLanguagePackage.BOUNDED_SCOPE: |
94 | sequence_BoundedScopeDefinition(context, (BoundedScopeDefinition) semanticObject); | 106 | sequence_BoundedScope(context, (BoundedScope) semanticObject); |
95 | return; | 107 | return; |
96 | case SolverLanguagePackage.CALL: | 108 | case SolverLanguagePackage.CALL: |
97 | sequence_Call(context, (Call) semanticObject); | 109 | sequence_Call(context, (Call) semanticObject); |
@@ -109,97 +121,103 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
109 | case SolverLanguagePackage.CAST_EXPRESSION: | 121 | case SolverLanguagePackage.CAST_EXPRESSION: |
110 | sequence_CastExpression(context, (CastExpression) semanticObject); | 122 | sequence_CastExpression(context, (CastExpression) semanticObject); |
111 | return; | 123 | return; |
112 | case SolverLanguagePackage.CLASS_DEFINITION: | 124 | case SolverLanguagePackage.CLASS_DECLARATION: |
113 | sequence_ClassDefinition(context, (ClassDefinition) semanticObject); | 125 | sequence_ClassDeclaration(context, (ClassDeclaration) semanticObject); |
114 | return; | 126 | return; |
115 | case SolverLanguagePackage.COMPARISON: | 127 | case SolverLanguagePackage.CONDITIONAL_EXPRESSION: |
116 | sequence_ComparisonExpression(context, (Comparison) semanticObject); | 128 | sequence_ConditionalExpression(context, (ConditionalExpression) semanticObject); |
117 | return; | 129 | return; |
118 | case SolverLanguagePackage.CONJUNCTION: | 130 | case SolverLanguagePackage.CONJUNCTION: |
119 | sequence_ConjunctiveExpression(context, (Conjunction) semanticObject); | 131 | sequence_ConjunctiveExpression(context, (Conjunction) semanticObject); |
120 | return; | 132 | return; |
121 | case SolverLanguagePackage.DEFAULT_DEFINITION: | 133 | case SolverLanguagePackage.COUNT: |
122 | sequence_DefaultDefinition(context, (DefaultDefinition) semanticObject); | 134 | sequence_Count(context, (Count) semanticObject); |
135 | return; | ||
136 | case SolverLanguagePackage.DEFAULT_ASSERTION: | ||
137 | sequence_DefaultAssertion(context, (DefaultAssertion) semanticObject); | ||
123 | return; | 138 | return; |
124 | case SolverLanguagePackage.DISJUNCTION: | 139 | case SolverLanguagePackage.DISJUNCTION: |
125 | sequence_DisjunctiveExpression(context, (Disjunction) semanticObject); | 140 | sequence_DisjunctiveExpression(context, (Disjunction) semanticObject); |
126 | return; | 141 | return; |
127 | case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: | 142 | case SolverLanguagePackage.EMPTY_LITERAL: |
128 | sequence_EmptyIntervalLiteral(context, (EmptyIntervalLiteral) semanticObject); | 143 | sequence_EmptyLiteral(context, (EmptyLiteral) semanticObject); |
144 | return; | ||
145 | case SolverLanguagePackage.ENUM_DECLARATION: | ||
146 | sequence_EnumDeclaration(context, (EnumDeclaration) semanticObject); | ||
147 | return; | ||
148 | case SolverLanguagePackage.ENUM_LITERAL: | ||
149 | sequence_EnumLiteral(context, (EnumLiteral) semanticObject); | ||
129 | return; | 150 | return; |
130 | case SolverLanguagePackage.EXACT_MULTIPLICITY: | 151 | case SolverLanguagePackage.EXACT_MULTIPLICITY: |
131 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); | 152 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); |
132 | return; | 153 | return; |
133 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: | 154 | case SolverLanguagePackage.EXACT_SCOPE: |
134 | sequence_ExactScopeDefinition(context, (ExactScopeDefinition) semanticObject); | 155 | sequence_ExactScope(context, (ExactScope) semanticObject); |
135 | return; | 156 | return; |
136 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: | 157 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: |
137 | sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject); | 158 | sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject); |
138 | return; | 159 | return; |
139 | case SolverLanguagePackage.EXTERN_AGGREGATOR_DEFINITION: | 160 | case SolverLanguagePackage.EXTERN_AGGREGATION_OPERATOR_DECLARATION: |
140 | sequence_ExternAggregatorDefinition(context, (ExternAggregatorDefinition) semanticObject); | 161 | sequence_ExternAggregationOperatorDeclaration(context, (ExternAggregationOperatorDeclaration) semanticObject); |
162 | return; | ||
163 | case SolverLanguagePackage.EXTERN_DATATYPE_DECLARATION: | ||
164 | sequence_ExternDatatypeDeclaration(context, (ExternDatatypeDeclaration) semanticObject); | ||
141 | return; | 165 | return; |
142 | case SolverLanguagePackage.EXTERN_DATATYPE_DEFINITION: | 166 | case SolverLanguagePackage.EXTERN_FUNCTION_DECLARATION: |
143 | sequence_ExternDatatypeDefinition(context, (ExternDatatypeDefinition) semanticObject); | 167 | sequence_ExternFunctionDeclaration(context, (ExternFunctionDeclaration) semanticObject); |
144 | return; | 168 | return; |
145 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: | 169 | case SolverLanguagePackage.EXTERN_PREDICATE_DECLARATION: |
146 | sequence_ExternMetricDefinition(context, (ExternMetricDefinition) semanticObject); | 170 | sequence_ExternPredicateDeclaration(context, (ExternPredicateDeclaration) semanticObject); |
147 | return; | 171 | return; |
148 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: | 172 | case SolverLanguagePackage.FIELD: |
149 | sequence_ExternPredicateDefinition(context, (ExternPredicateDefinition) semanticObject); | 173 | sequence_Field(context, (Field) semanticObject); |
150 | return; | 174 | return; |
151 | case SolverLanguagePackage.IF_ELSE: | 175 | case SolverLanguagePackage.FORALL: |
152 | sequence_IfElse(context, (IfElse) semanticObject); | 176 | sequence_Expression(context, (Forall) semanticObject); |
153 | return; | 177 | return; |
178 | case SolverLanguagePackage.FUNCTION_DEFINITION: | ||
179 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | ||
180 | sequence_AssertionOrDefinition(context, (FunctionDefinition) semanticObject); | ||
181 | return; | ||
182 | } | ||
183 | else if (rule == grammarAccess.getStatementRule()) { | ||
184 | sequence_AssertionOrDefinition_FunctionDefinition(context, (FunctionDefinition) semanticObject); | ||
185 | return; | ||
186 | } | ||
187 | else if (rule == grammarAccess.getFunctionDefinitionRule()) { | ||
188 | sequence_FunctionDefinition(context, (FunctionDefinition) semanticObject); | ||
189 | return; | ||
190 | } | ||
191 | else break; | ||
154 | case SolverLanguagePackage.INFINITY_LITERAL: | 192 | case SolverLanguagePackage.INFINITY_LITERAL: |
155 | sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject); | 193 | sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject); |
156 | return; | 194 | return; |
157 | case SolverLanguagePackage.INTERPRETATION: | 195 | case SolverLanguagePackage.INT_LITERAL: |
158 | sequence_AssertionOrDefinition(context, (Interpretation) semanticObject); | 196 | sequence_IntLiteral(context, (IntLiteral) semanticObject); |
159 | return; | 197 | return; |
160 | case SolverLanguagePackage.INTERVAL: | 198 | case SolverLanguagePackage.INTERVAL: |
161 | sequence_Interval(context, (Interval) semanticObject); | 199 | sequence_Interval(context, (Interval) semanticObject); |
162 | return; | 200 | return; |
163 | case SolverLanguagePackage.LET: | ||
164 | sequence_Let(context, (Let) semanticObject); | ||
165 | return; | ||
166 | case SolverLanguagePackage.LET_BINDING: | 201 | case SolverLanguagePackage.LET_BINDING: |
167 | sequence_LetBinding(context, (LetBinding) semanticObject); | 202 | sequence_LetBinding(context, (LetBinding) semanticObject); |
168 | return; | 203 | return; |
169 | case SolverLanguagePackage.LOCAL_VARIABLES: | 204 | case SolverLanguagePackage.LET_EXPRESSION: |
170 | sequence_LocalVariables(context, (LocalVariables) semanticObject); | 205 | sequence_LetExpression(context, (LetExpression) semanticObject); |
171 | return; | 206 | return; |
172 | case SolverLanguagePackage.LOGIC_LITERAL: | 207 | case SolverLanguagePackage.LOGIC_LITERAL: |
173 | sequence_LogicLiteral(context, (LogicLiteral) semanticObject); | 208 | sequence_LogicLiteral(context, (LogicLiteral) semanticObject); |
174 | return; | 209 | return; |
175 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: | 210 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE: |
176 | sequence_LowerBoundedScopeDefinition(context, (LowerBoundedScopeDefinition) semanticObject); | 211 | sequence_LowerBoundedScope(context, (LowerBoundedScope) semanticObject); |
177 | return; | 212 | return; |
178 | case SolverLanguagePackage.MANY_MULTIPLICITY: | 213 | case SolverLanguagePackage.NAMESPACE_IMPORT: |
179 | sequence_ManyMultiplicity(context, (ManyMultiplicity) semanticObject); | 214 | sequence_NamespaceImport(context, (NamespaceImport) semanticObject); |
180 | return; | 215 | return; |
181 | case SolverLanguagePackage.MEMBER_DEFINITION: | 216 | case SolverLanguagePackage.OBJECTIVE_DECLARATION: |
182 | sequence_MemberDefinition(context, (MemberDefinition) semanticObject); | 217 | sequence_ObjectiveDeclaration(context, (ObjectiveDeclaration) semanticObject); |
183 | return; | 218 | return; |
184 | case SolverLanguagePackage.METRIC_DEFINITION: | 219 | case SolverLanguagePackage.PATH_COMPONENT: |
185 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | 220 | sequence_PathComponent(context, (PathComponent) semanticObject); |
186 | sequence_AssertionOrDefinition(context, (MetricDefinition) semanticObject); | ||
187 | return; | ||
188 | } | ||
189 | else if (rule == grammarAccess.getStatementRule()) { | ||
190 | sequence_AssertionOrDefinition_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
191 | return; | ||
192 | } | ||
193 | else if (rule == grammarAccess.getMetricDefinitionRule()) { | ||
194 | sequence_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
195 | return; | ||
196 | } | ||
197 | else break; | ||
198 | case SolverLanguagePackage.NUMERIC_LITERAL: | ||
199 | sequence_NumericLiteral(context, (NumericLiteral) semanticObject); | ||
200 | return; | ||
201 | case SolverLanguagePackage.OBJECTIVE_DEFINITION: | ||
202 | sequence_ObjectiveDefinition(context, (ObjectiveDefinition) semanticObject); | ||
203 | return; | 221 | return; |
204 | case SolverLanguagePackage.PREDICATE_DEFINITION: | 222 | case SolverLanguagePackage.PREDICATE_DEFINITION: |
205 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | 223 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { |
@@ -218,8 +236,8 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
218 | case SolverLanguagePackage.PROBLEM: | 236 | case SolverLanguagePackage.PROBLEM: |
219 | sequence_Problem(context, (Problem) semanticObject); | 237 | sequence_Problem(context, (Problem) semanticObject); |
220 | return; | 238 | return; |
221 | case SolverLanguagePackage.QUANTIFIED_EXPRESSION: | 239 | case SolverLanguagePackage.REAL_LITERAL: |
222 | sequence_QuantifiedExpression(context, (QuantifiedExpression) semanticObject); | 240 | sequence_RealLiteral(context, (RealLiteral) semanticObject); |
223 | return; | 241 | return; |
224 | case SolverLanguagePackage.REFERENCE: | 242 | case SolverLanguagePackage.REFERENCE: |
225 | sequence_Reference(context, (Reference) semanticObject); | 243 | sequence_Reference(context, (Reference) semanticObject); |
@@ -233,20 +251,26 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
233 | case SolverLanguagePackage.SWITCH: | 251 | case SolverLanguagePackage.SWITCH: |
234 | sequence_DisjunctiveExpression(context, (Switch) semanticObject); | 252 | sequence_DisjunctiveExpression(context, (Switch) semanticObject); |
235 | return; | 253 | return; |
236 | case SolverLanguagePackage.TYPED_ARGUMENT: | 254 | case SolverLanguagePackage.TYPE_REFERENCE: |
237 | sequence_TypedArgument(context, (TypedArgument) semanticObject); | 255 | sequence_TypeReference(context, (TypeReference) semanticObject); |
238 | return; | 256 | return; |
239 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: | 257 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: |
240 | sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject); | 258 | sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject); |
241 | return; | 259 | return; |
260 | case SolverLanguagePackage.TYPED_VARIABLE_ARGUMENT: | ||
261 | sequence_TypedVariableArgument(context, (TypedVariableArgument) semanticObject); | ||
262 | return; | ||
242 | case SolverLanguagePackage.UNARY_EXPRESSION: | 263 | case SolverLanguagePackage.UNARY_EXPRESSION: |
243 | sequence_UnaryExpression(context, (UnaryExpression) semanticObject); | 264 | sequence_UnaryExpression(context, (UnaryExpression) semanticObject); |
244 | return; | 265 | return; |
245 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: | 266 | case SolverLanguagePackage.UNBOUNDED_MULTIPLICITY: |
246 | sequence_UnnamedErrorPrediateDefinition(context, (UnnamedErrorPrediateDefinition) semanticObject); | 267 | sequence_UnboundedMultiplicity(context, (UnboundedMultiplicity) semanticObject); |
247 | return; | 268 | return; |
248 | case SolverLanguagePackage.VARIABLE: | 269 | case SolverLanguagePackage.UNNAMED_ERROR_PREDICATE_DEFINTION: |
249 | sequence_Variable(context, (Variable) semanticObject); | 270 | sequence_UnnamedErrorPredicateDefintion(context, (UnnamedErrorPredicateDefintion) semanticObject); |
271 | return; | ||
272 | case SolverLanguagePackage.URI_IMPORT: | ||
273 | sequence_UriImport(context, (UriImport) semanticObject); | ||
250 | return; | 274 | return; |
251 | } | 275 | } |
252 | if (errorAcceptor != null) | 276 | if (errorAcceptor != null) |
@@ -255,21 +279,18 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
255 | 279 | ||
256 | /** | 280 | /** |
257 | * Contexts: | 281 | * Contexts: |
258 | * Statement returns BinaryExpression | 282 | * AssertionOrDefinition.Assertion_1_0_0 returns BinaryExpression |
259 | * AssertionOrDefinition returns BinaryExpression | ||
260 | * AssertionOrDefinition.Interpretation_1_0_0 returns BinaryExpression | ||
261 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression | 283 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression |
262 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns BinaryExpression | 284 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns BinaryExpression |
263 | * Expression returns BinaryExpression | 285 | * Expression returns BinaryExpression |
264 | * ImplicationExpression returns BinaryExpression | 286 | * Expression.Forall_2_1_0 returns BinaryExpression |
265 | * ImplicationExpression.BinaryExpression_1_0 returns BinaryExpression | ||
266 | * DisjunctiveExpression returns BinaryExpression | 287 | * DisjunctiveExpression returns BinaryExpression |
267 | * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression | 288 | * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression |
268 | * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression | 289 | * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression |
269 | * ConjunctiveExpression returns BinaryExpression | 290 | * ConjunctiveExpression returns BinaryExpression |
270 | * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression | 291 | * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression |
271 | * ComparisonExpression returns BinaryExpression | 292 | * ComparisonExpression returns BinaryExpression |
272 | * ComparisonExpression.Comparison_1_0 returns BinaryExpression | 293 | * ComparisonExpression.BinaryExpression_1_0 returns BinaryExpression |
273 | * AdditiveExpression returns BinaryExpression | 294 | * AdditiveExpression returns BinaryExpression |
274 | * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression | 295 | * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression |
275 | * MultiplicativeExpression returns BinaryExpression | 296 | * MultiplicativeExpression returns BinaryExpression |
@@ -279,39 +300,36 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
279 | * CastExpression returns BinaryExpression | 300 | * CastExpression returns BinaryExpression |
280 | * CastExpression.CastExpression_1_0 returns BinaryExpression | 301 | * CastExpression.CastExpression_1_0 returns BinaryExpression |
281 | * UnaryExpression returns BinaryExpression | 302 | * UnaryExpression returns BinaryExpression |
282 | * AggregationExpression returns BinaryExpression | 303 | * BracedAggregateExpression returns BinaryExpression |
283 | * AtomicExpression returns BinaryExpression | 304 | * AtomicExpression returns BinaryExpression |
284 | * | 305 | * |
285 | * Constraint: | 306 | * Constraint: |
286 | * ( | 307 | * ( |
287 | * (left=ImplicationExpression_BinaryExpression_1_0 op=ImplicationOperator right=ImplicationExpression) | | 308 | * (left=ComparisonExpression_BinaryExpression_1_0 op=ComparisonOperator right=AdditiveExpression) | |
288 | * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) | | 309 | * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) | |
289 | * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) | | 310 | * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) | |
290 | * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=CastExpression) | 311 | * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=CastExpression) |
291 | * ) | 312 | * ) |
292 | */ | 313 | */ |
293 | protected void sequence_AdditiveExpression_ExponentialExpression_ImplicationExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) { | 314 | protected void sequence_AdditiveExpression_ComparisonExpression_ExponentialExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) { |
294 | genericSequencer.createSequence(context, semanticObject); | 315 | genericSequencer.createSequence(context, semanticObject); |
295 | } | 316 | } |
296 | 317 | ||
297 | 318 | ||
298 | /** | 319 | /** |
299 | * Contexts: | 320 | * Contexts: |
300 | * Statement returns Aggregation | 321 | * AssertionOrDefinition.Assertion_1_0_0 returns Aggregation |
301 | * AssertionOrDefinition returns Aggregation | ||
302 | * AssertionOrDefinition.Interpretation_1_0_0 returns Aggregation | ||
303 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation | 322 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation |
304 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Aggregation | 323 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Aggregation |
305 | * Expression returns Aggregation | 324 | * Expression returns Aggregation |
306 | * ImplicationExpression returns Aggregation | 325 | * Expression.Forall_2_1_0 returns Aggregation |
307 | * ImplicationExpression.BinaryExpression_1_0 returns Aggregation | ||
308 | * DisjunctiveExpression returns Aggregation | 326 | * DisjunctiveExpression returns Aggregation |
309 | * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation | 327 | * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation |
310 | * DisjunctiveExpression.Case_1_1_0 returns Aggregation | 328 | * DisjunctiveExpression.Case_1_1_0 returns Aggregation |
311 | * ConjunctiveExpression returns Aggregation | 329 | * ConjunctiveExpression returns Aggregation |
312 | * ConjunctiveExpression.Conjunction_1_0 returns Aggregation | 330 | * ConjunctiveExpression.Conjunction_1_0 returns Aggregation |
313 | * ComparisonExpression returns Aggregation | 331 | * ComparisonExpression returns Aggregation |
314 | * ComparisonExpression.Comparison_1_0 returns Aggregation | 332 | * ComparisonExpression.BinaryExpression_1_0 returns Aggregation |
315 | * AdditiveExpression returns Aggregation | 333 | * AdditiveExpression returns Aggregation |
316 | * AdditiveExpression.BinaryExpression_1_0 returns Aggregation | 334 | * AdditiveExpression.BinaryExpression_1_0 returns Aggregation |
317 | * MultiplicativeExpression returns Aggregation | 335 | * MultiplicativeExpression returns Aggregation |
@@ -321,15 +339,27 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
321 | * CastExpression returns Aggregation | 339 | * CastExpression returns Aggregation |
322 | * CastExpression.CastExpression_1_0 returns Aggregation | 340 | * CastExpression.CastExpression_1_0 returns Aggregation |
323 | * UnaryExpression returns Aggregation | 341 | * UnaryExpression returns Aggregation |
324 | * AggregationExpression returns Aggregation | 342 | * BracedAggregateExpression returns Aggregation |
325 | * Aggregation returns Aggregation | 343 | * Aggregation returns Aggregation |
326 | * AtomicExpression returns Aggregation | 344 | * AtomicExpression returns Aggregation |
327 | * | 345 | * |
328 | * Constraint: | 346 | * Constraint: |
329 | * (op=[NamedElement|QualifiedName] localVariables=LocalVariables? body=Expression condition=Expression?) | 347 | * (op=[Symbol|QualifiedName] value=Expression condition=Expression) |
330 | */ | 348 | */ |
331 | protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) { | 349 | protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) { |
332 | genericSequencer.createSequence(context, semanticObject); | 350 | if (errorAcceptor != null) { |
351 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP) == ValueTransient.YES) | ||
352 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP)); | ||
353 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__VALUE) == ValueTransient.YES) | ||
354 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__VALUE)); | ||
355 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) | ||
356 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); | ||
357 | } | ||
358 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
359 | feeder.accept(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.AGGREGATION__OP, false)); | ||
360 | feeder.accept(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0(), semanticObject.getValue()); | ||
361 | feeder.accept(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0(), semanticObject.getCondition()); | ||
362 | feeder.finish(); | ||
333 | } | 363 | } |
334 | 364 | ||
335 | 365 | ||
@@ -347,42 +377,33 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
347 | 377 | ||
348 | /** | 378 | /** |
349 | * Contexts: | 379 | * Contexts: |
350 | * Statement returns Interpretation | 380 | * Statement returns Assertion |
351 | * AssertionOrDefinition returns Interpretation | 381 | * AssertionOrDefinition returns Assertion |
352 | * | 382 | * |
353 | * Constraint: | 383 | * Constraint: |
354 | * (body=AssertionOrDefinition_Interpretation_1_0_0 range=Expression) | 384 | * (expression=AssertionOrDefinition_Assertion_1_0_0 range=Expression?) |
355 | */ | 385 | */ |
356 | protected void sequence_AssertionOrDefinition(ISerializationContext context, Interpretation semanticObject) { | 386 | protected void sequence_AssertionOrDefinition(ISerializationContext context, Assertion semanticObject) { |
357 | if (errorAcceptor != null) { | 387 | genericSequencer.createSequence(context, semanticObject); |
358 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERPRETATION__BODY) == ValueTransient.YES) | ||
359 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERPRETATION__BODY)); | ||
360 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERPRETATION__RANGE) == ValueTransient.YES) | ||
361 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERPRETATION__RANGE)); | ||
362 | } | ||
363 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
364 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getInterpretationBodyAction_1_0_0(), semanticObject.getBody()); | ||
365 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_2_0(), semanticObject.getRange()); | ||
366 | feeder.finish(); | ||
367 | } | 388 | } |
368 | 389 | ||
369 | 390 | ||
370 | /** | 391 | /** |
371 | * Contexts: | 392 | * Contexts: |
372 | * AssertionOrDefinition returns MetricDefinition | 393 | * AssertionOrDefinition returns FunctionDefinition |
373 | * | 394 | * |
374 | * Constraint: | 395 | * Constraint: |
375 | * (head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) | 396 | * (head=AssertionOrDefinition_FunctionDefinition_1_2_0 body=Expression) |
376 | */ | 397 | */ |
377 | protected void sequence_AssertionOrDefinition(ISerializationContext context, MetricDefinition semanticObject) { | 398 | protected void sequence_AssertionOrDefinition(ISerializationContext context, FunctionDefinition semanticObject) { |
378 | if (errorAcceptor != null) { | 399 | if (errorAcceptor != null) { |
379 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) | 400 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) |
380 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); | 401 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); |
381 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | 402 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) |
382 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | 403 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); |
383 | } | 404 | } |
384 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 405 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
385 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), semanticObject.getHead()); | 406 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0(), semanticObject.getHead()); |
386 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody()); | 407 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody()); |
387 | feeder.finish(); | 408 | feeder.finish(); |
388 | } | 409 | } |
@@ -390,12 +411,12 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
390 | 411 | ||
391 | /** | 412 | /** |
392 | * Contexts: | 413 | * Contexts: |
393 | * Statement returns MetricDefinition | 414 | * Statement returns FunctionDefinition |
394 | * | 415 | * |
395 | * Constraint: | 416 | * Constraint: |
396 | * ((head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) | (type=[NamedElement|QualifiedName] head=Call body=Expression)) | 417 | * ((head=AssertionOrDefinition_FunctionDefinition_1_2_0 body=Expression) | (resultType=[Symbol|QualifiedName] head=Call body=Expression)) |
397 | */ | 418 | */ |
398 | protected void sequence_AssertionOrDefinition_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { | 419 | protected void sequence_AssertionOrDefinition_FunctionDefinition(ISerializationContext context, FunctionDefinition semanticObject) { |
399 | genericSequencer.createSequence(context, semanticObject); | 420 | genericSequencer.createSequence(context, semanticObject); |
400 | } | 421 | } |
401 | 422 | ||
@@ -409,10 +430,10 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
409 | */ | 430 | */ |
410 | protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) { | 431 | protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
411 | if (errorAcceptor != null) { | 432 | if (errorAcceptor != null) { |
412 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD) == ValueTransient.YES) | 433 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) |
413 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD)); | 434 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); |
414 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY) == ValueTransient.YES) | 435 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) |
415 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY)); | 436 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); |
416 | } | 437 | } |
417 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 438 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
418 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead()); | 439 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead()); |
@@ -438,6 +459,28 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
438 | 459 | ||
439 | /** | 460 | /** |
440 | * Contexts: | 461 | * Contexts: |
462 | * Statement returns Attribute | ||
463 | * Attribute returns Attribute | ||
464 | * | ||
465 | * Constraint: | ||
466 | * (kind=AttributeKind target=[Symbol|QualifiedName]) | ||
467 | */ | ||
468 | protected void sequence_Attribute(ISerializationContext context, Attribute semanticObject) { | ||
469 | if (errorAcceptor != null) { | ||
470 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__KIND) == ValueTransient.YES) | ||
471 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__KIND)); | ||
472 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__TARGET) == ValueTransient.YES) | ||
473 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__TARGET)); | ||
474 | } | ||
475 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
476 | feeder.accept(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
477 | feeder.accept(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.ATTRIBUTE__TARGET, false)); | ||
478 | feeder.finish(); | ||
479 | } | ||
480 | |||
481 | |||
482 | /** | ||
483 | * Contexts: | ||
441 | * Multiplicity returns BoundedMultiplicity | 484 | * Multiplicity returns BoundedMultiplicity |
442 | * BoundedMultiplicity returns BoundedMultiplicity | 485 | * BoundedMultiplicity returns BoundedMultiplicity |
443 | * | 486 | * |
@@ -460,35 +503,32 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
460 | 503 | ||
461 | /** | 504 | /** |
462 | * Contexts: | 505 | * Contexts: |
463 | * Statement returns BoundedScopeDefinition | 506 | * Statement returns BoundedScope |
464 | * ScopeDefinition returns BoundedScopeDefinition | 507 | * ScopeDeclaration returns BoundedScope |
465 | * BoundedScopeDefinition returns BoundedScopeDefinition | 508 | * BoundedScope returns BoundedScope |
466 | * | 509 | * |
467 | * Constraint: | 510 | * Constraint: |
468 | * ((lowerBound=INT? type=[NamedElement|QualifiedName] upperBound=INT) | (upperBound=INT type=[NamedElement|QualifiedName] lowerBound=INT?)) | 511 | * ((lowerBound=INT? type=[Symbol|QualifiedName] upperBound=INT) | (upperBound=INT type=[Symbol|QualifiedName] lowerBound=INT?)) |
469 | */ | 512 | */ |
470 | protected void sequence_BoundedScopeDefinition(ISerializationContext context, BoundedScopeDefinition semanticObject) { | 513 | protected void sequence_BoundedScope(ISerializationContext context, BoundedScope semanticObject) { |
471 | genericSequencer.createSequence(context, semanticObject); | 514 | genericSequencer.createSequence(context, semanticObject); |
472 | } | 515 | } |
473 | 516 | ||
474 | 517 | ||
475 | /** | 518 | /** |
476 | * Contexts: | 519 | * Contexts: |
477 | * Statement returns Call | 520 | * AssertionOrDefinition.Assertion_1_0_0 returns Call |
478 | * AssertionOrDefinition returns Call | ||
479 | * AssertionOrDefinition.Interpretation_1_0_0 returns Call | ||
480 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call | 521 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call |
481 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Call | 522 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Call |
482 | * Expression returns Call | 523 | * Expression returns Call |
483 | * ImplicationExpression returns Call | 524 | * Expression.Forall_2_1_0 returns Call |
484 | * ImplicationExpression.BinaryExpression_1_0 returns Call | ||
485 | * DisjunctiveExpression returns Call | 525 | * DisjunctiveExpression returns Call |
486 | * DisjunctiveExpression.Disjunction_1_0_0 returns Call | 526 | * DisjunctiveExpression.Disjunction_1_0_0 returns Call |
487 | * DisjunctiveExpression.Case_1_1_0 returns Call | 527 | * DisjunctiveExpression.Case_1_1_0 returns Call |
488 | * ConjunctiveExpression returns Call | 528 | * ConjunctiveExpression returns Call |
489 | * ConjunctiveExpression.Conjunction_1_0 returns Call | 529 | * ConjunctiveExpression.Conjunction_1_0 returns Call |
490 | * ComparisonExpression returns Call | 530 | * ComparisonExpression returns Call |
491 | * ComparisonExpression.Comparison_1_0 returns Call | 531 | * ComparisonExpression.BinaryExpression_1_0 returns Call |
492 | * AdditiveExpression returns Call | 532 | * AdditiveExpression returns Call |
493 | * AdditiveExpression.BinaryExpression_1_0 returns Call | 533 | * AdditiveExpression.BinaryExpression_1_0 returns Call |
494 | * MultiplicativeExpression returns Call | 534 | * MultiplicativeExpression returns Call |
@@ -498,19 +538,24 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
498 | * CastExpression returns Call | 538 | * CastExpression returns Call |
499 | * CastExpression.CastExpression_1_0 returns Call | 539 | * CastExpression.CastExpression_1_0 returns Call |
500 | * UnaryExpression returns Call | 540 | * UnaryExpression returns Call |
501 | * AggregationExpression returns Call | 541 | * BracedAggregateExpression returns Call |
502 | * AtomicExpression returns Call | 542 | * AtomicExpression returns Call |
503 | * Call returns Call | 543 | * Call returns Call |
504 | * | 544 | * |
505 | * Constraint: | 545 | * Constraint: |
506 | * ( | 546 | * (functor=Reference argumentList=ArgumentList) |
507 | * functor=Reference | ||
508 | * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
509 | * argumentList=ArgumentList | ||
510 | * ) | ||
511 | */ | 547 | */ |
512 | protected void sequence_Call(ISerializationContext context, Call semanticObject) { | 548 | protected void sequence_Call(ISerializationContext context, Call semanticObject) { |
513 | genericSequencer.createSequence(context, semanticObject); | 549 | if (errorAcceptor != null) { |
550 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR) == ValueTransient.YES) | ||
551 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR)); | ||
552 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST) == ValueTransient.YES) | ||
553 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST)); | ||
554 | } | ||
555 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
556 | feeder.accept(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0(), semanticObject.getFunctor()); | ||
557 | feeder.accept(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); | ||
558 | feeder.finish(); | ||
514 | } | 559 | } |
515 | 560 | ||
516 | 561 | ||
@@ -537,21 +582,18 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
537 | 582 | ||
538 | /** | 583 | /** |
539 | * Contexts: | 584 | * Contexts: |
540 | * Statement returns CastExpression | 585 | * AssertionOrDefinition.Assertion_1_0_0 returns CastExpression |
541 | * AssertionOrDefinition returns CastExpression | ||
542 | * AssertionOrDefinition.Interpretation_1_0_0 returns CastExpression | ||
543 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns CastExpression | 586 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns CastExpression |
544 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns CastExpression | 587 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns CastExpression |
545 | * Expression returns CastExpression | 588 | * Expression returns CastExpression |
546 | * ImplicationExpression returns CastExpression | 589 | * Expression.Forall_2_1_0 returns CastExpression |
547 | * ImplicationExpression.BinaryExpression_1_0 returns CastExpression | ||
548 | * DisjunctiveExpression returns CastExpression | 590 | * DisjunctiveExpression returns CastExpression |
549 | * DisjunctiveExpression.Disjunction_1_0_0 returns CastExpression | 591 | * DisjunctiveExpression.Disjunction_1_0_0 returns CastExpression |
550 | * DisjunctiveExpression.Case_1_1_0 returns CastExpression | 592 | * DisjunctiveExpression.Case_1_1_0 returns CastExpression |
551 | * ConjunctiveExpression returns CastExpression | 593 | * ConjunctiveExpression returns CastExpression |
552 | * ConjunctiveExpression.Conjunction_1_0 returns CastExpression | 594 | * ConjunctiveExpression.Conjunction_1_0 returns CastExpression |
553 | * ComparisonExpression returns CastExpression | 595 | * ComparisonExpression returns CastExpression |
554 | * ComparisonExpression.Comparison_1_0 returns CastExpression | 596 | * ComparisonExpression.BinaryExpression_1_0 returns CastExpression |
555 | * AdditiveExpression returns CastExpression | 597 | * AdditiveExpression returns CastExpression |
556 | * AdditiveExpression.BinaryExpression_1_0 returns CastExpression | 598 | * AdditiveExpression.BinaryExpression_1_0 returns CastExpression |
557 | * MultiplicativeExpression returns CastExpression | 599 | * MultiplicativeExpression returns CastExpression |
@@ -561,110 +603,100 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
561 | * CastExpression returns CastExpression | 603 | * CastExpression returns CastExpression |
562 | * CastExpression.CastExpression_1_0 returns CastExpression | 604 | * CastExpression.CastExpression_1_0 returns CastExpression |
563 | * UnaryExpression returns CastExpression | 605 | * UnaryExpression returns CastExpression |
564 | * AggregationExpression returns CastExpression | 606 | * BracedAggregateExpression returns CastExpression |
565 | * AtomicExpression returns CastExpression | 607 | * AtomicExpression returns CastExpression |
566 | * | 608 | * |
567 | * Constraint: | 609 | * Constraint: |
568 | * (body=CastExpression_CastExpression_1_0 type=[NamedElement|QualifiedName]) | 610 | * (body=CastExpression_CastExpression_1_0 targetType=[Symbol|QualifiedName]) |
569 | */ | 611 | */ |
570 | protected void sequence_CastExpression(ISerializationContext context, CastExpression semanticObject) { | 612 | protected void sequence_CastExpression(ISerializationContext context, CastExpression semanticObject) { |
571 | if (errorAcceptor != null) { | 613 | if (errorAcceptor != null) { |
572 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY) == ValueTransient.YES) | 614 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY) == ValueTransient.YES) |
573 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY)); | 615 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY)); |
574 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TYPE) == ValueTransient.YES) | 616 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE) == ValueTransient.YES) |
575 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TYPE)); | 617 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE)); |
576 | } | 618 | } |
577 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 619 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
578 | feeder.accept(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0(), semanticObject.getBody()); | 620 | feeder.accept(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0(), semanticObject.getBody()); |
579 | feeder.accept(grammarAccess.getCastExpressionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_2_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.CAST_EXPRESSION__TYPE, false)); | 621 | feeder.accept(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE, false)); |
580 | feeder.finish(); | 622 | feeder.finish(); |
581 | } | 623 | } |
582 | 624 | ||
583 | 625 | ||
584 | /** | 626 | /** |
585 | * Contexts: | 627 | * Contexts: |
586 | * Statement returns ClassDefinition | 628 | * Statement returns ClassDeclaration |
587 | * ClassDefinition returns ClassDefinition | 629 | * ClassDeclaration returns ClassDeclaration |
588 | * | 630 | * |
589 | * Constraint: | 631 | * Constraint: |
590 | * ( | 632 | * ((abstract?='abstract' | root?='root')* name=ID (supertypes+=[Symbol|QualifiedName] supertypes+=[Symbol|QualifiedName]*)? fields+=Field*) |
591 | * abstract?='abstract'? | ||
592 | * name=ID | ||
593 | * (superclasses+=[NamedElement|QualifiedName] superclasses+=[NamedElement|QualifiedName]*)? | ||
594 | * members+=MemberDefinition* | ||
595 | * ) | ||
596 | */ | 633 | */ |
597 | protected void sequence_ClassDefinition(ISerializationContext context, ClassDefinition semanticObject) { | 634 | protected void sequence_ClassDeclaration(ISerializationContext context, ClassDeclaration semanticObject) { |
598 | genericSequencer.createSequence(context, semanticObject); | 635 | genericSequencer.createSequence(context, semanticObject); |
599 | } | 636 | } |
600 | 637 | ||
601 | 638 | ||
602 | /** | 639 | /** |
603 | * Contexts: | 640 | * Contexts: |
604 | * Statement returns Comparison | 641 | * AssertionOrDefinition.Assertion_1_0_0 returns ConditionalExpression |
605 | * AssertionOrDefinition returns Comparison | 642 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns ConditionalExpression |
606 | * AssertionOrDefinition.Interpretation_1_0_0 returns Comparison | 643 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns ConditionalExpression |
607 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Comparison | 644 | * Expression returns ConditionalExpression |
608 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Comparison | 645 | * Expression.Forall_2_1_0 returns ConditionalExpression |
609 | * Expression returns Comparison | 646 | * ConditionalExpression returns ConditionalExpression |
610 | * ImplicationExpression returns Comparison | 647 | * DisjunctiveExpression returns ConditionalExpression |
611 | * ImplicationExpression.BinaryExpression_1_0 returns Comparison | 648 | * DisjunctiveExpression.Disjunction_1_0_0 returns ConditionalExpression |
612 | * DisjunctiveExpression returns Comparison | 649 | * DisjunctiveExpression.Case_1_1_0 returns ConditionalExpression |
613 | * DisjunctiveExpression.Disjunction_1_0_0 returns Comparison | 650 | * ConjunctiveExpression returns ConditionalExpression |
614 | * DisjunctiveExpression.Case_1_1_0 returns Comparison | 651 | * ConjunctiveExpression.Conjunction_1_0 returns ConditionalExpression |
615 | * ConjunctiveExpression returns Comparison | 652 | * ComparisonExpression returns ConditionalExpression |
616 | * ConjunctiveExpression.Conjunction_1_0 returns Comparison | 653 | * ComparisonExpression.BinaryExpression_1_0 returns ConditionalExpression |
617 | * ComparisonExpression returns Comparison | 654 | * AdditiveExpression returns ConditionalExpression |
618 | * ComparisonExpression.Comparison_1_0 returns Comparison | 655 | * AdditiveExpression.BinaryExpression_1_0 returns ConditionalExpression |
619 | * AdditiveExpression returns Comparison | 656 | * MultiplicativeExpression returns ConditionalExpression |
620 | * AdditiveExpression.BinaryExpression_1_0 returns Comparison | 657 | * MultiplicativeExpression.BinaryExpression_1_0 returns ConditionalExpression |
621 | * MultiplicativeExpression returns Comparison | 658 | * ExponentialExpression returns ConditionalExpression |
622 | * MultiplicativeExpression.BinaryExpression_1_0 returns Comparison | 659 | * ExponentialExpression.BinaryExpression_1_0 returns ConditionalExpression |
623 | * ExponentialExpression returns Comparison | 660 | * CastExpression returns ConditionalExpression |
624 | * ExponentialExpression.BinaryExpression_1_0 returns Comparison | 661 | * CastExpression.CastExpression_1_0 returns ConditionalExpression |
625 | * CastExpression returns Comparison | 662 | * UnaryExpression returns ConditionalExpression |
626 | * CastExpression.CastExpression_1_0 returns Comparison | 663 | * BracedAggregateExpression returns ConditionalExpression |
627 | * UnaryExpression returns Comparison | 664 | * AtomicExpression returns ConditionalExpression |
628 | * AggregationExpression returns Comparison | ||
629 | * AtomicExpression returns Comparison | ||
630 | * | 665 | * |
631 | * Constraint: | 666 | * Constraint: |
632 | * (left=ComparisonExpression_Comparison_1_0 op=ComparisonOperator right=AdditiveExpression) | 667 | * (condition=DisjunctiveExpression then=Expression else=Expression) |
633 | */ | 668 | */ |
634 | protected void sequence_ComparisonExpression(ISerializationContext context, Comparison semanticObject) { | 669 | protected void sequence_ConditionalExpression(ISerializationContext context, ConditionalExpression semanticObject) { |
635 | if (errorAcceptor != null) { | 670 | if (errorAcceptor != null) { |
636 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT) == ValueTransient.YES) | 671 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__CONDITION) == ValueTransient.YES) |
637 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT)); | 672 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__CONDITION)); |
638 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP) == ValueTransient.YES) | 673 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__THEN) == ValueTransient.YES) |
639 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP)); | 674 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__THEN)); |
640 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT) == ValueTransient.YES) | 675 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__ELSE) == ValueTransient.YES) |
641 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT)); | 676 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__ELSE)); |
642 | } | 677 | } |
643 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 678 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
644 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), semanticObject.getLeft()); | 679 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0(), semanticObject.getCondition()); |
645 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0(), semanticObject.getOp()); | 680 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen()); |
646 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0(), semanticObject.getRight()); | 681 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse()); |
647 | feeder.finish(); | 682 | feeder.finish(); |
648 | } | 683 | } |
649 | 684 | ||
650 | 685 | ||
651 | /** | 686 | /** |
652 | * Contexts: | 687 | * Contexts: |
653 | * Statement returns Conjunction | 688 | * AssertionOrDefinition.Assertion_1_0_0 returns Conjunction |
654 | * AssertionOrDefinition returns Conjunction | ||
655 | * AssertionOrDefinition.Interpretation_1_0_0 returns Conjunction | ||
656 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction | 689 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction |
657 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Conjunction | 690 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Conjunction |
658 | * Expression returns Conjunction | 691 | * Expression returns Conjunction |
659 | * ImplicationExpression returns Conjunction | 692 | * Expression.Forall_2_1_0 returns Conjunction |
660 | * ImplicationExpression.BinaryExpression_1_0 returns Conjunction | ||
661 | * DisjunctiveExpression returns Conjunction | 693 | * DisjunctiveExpression returns Conjunction |
662 | * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction | 694 | * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction |
663 | * DisjunctiveExpression.Case_1_1_0 returns Conjunction | 695 | * DisjunctiveExpression.Case_1_1_0 returns Conjunction |
664 | * ConjunctiveExpression returns Conjunction | 696 | * ConjunctiveExpression returns Conjunction |
665 | * ConjunctiveExpression.Conjunction_1_0 returns Conjunction | 697 | * ConjunctiveExpression.Conjunction_1_0 returns Conjunction |
666 | * ComparisonExpression returns Conjunction | 698 | * ComparisonExpression returns Conjunction |
667 | * ComparisonExpression.Comparison_1_0 returns Conjunction | 699 | * ComparisonExpression.BinaryExpression_1_0 returns Conjunction |
668 | * AdditiveExpression returns Conjunction | 700 | * AdditiveExpression returns Conjunction |
669 | * AdditiveExpression.BinaryExpression_1_0 returns Conjunction | 701 | * AdditiveExpression.BinaryExpression_1_0 returns Conjunction |
670 | * MultiplicativeExpression returns Conjunction | 702 | * MultiplicativeExpression returns Conjunction |
@@ -674,7 +706,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
674 | * CastExpression returns Conjunction | 706 | * CastExpression returns Conjunction |
675 | * CastExpression.CastExpression_1_0 returns Conjunction | 707 | * CastExpression.CastExpression_1_0 returns Conjunction |
676 | * UnaryExpression returns Conjunction | 708 | * UnaryExpression returns Conjunction |
677 | * AggregationExpression returns Conjunction | 709 | * BracedAggregateExpression returns Conjunction |
678 | * AtomicExpression returns Conjunction | 710 | * AtomicExpression returns Conjunction |
679 | * | 711 | * |
680 | * Constraint: | 712 | * Constraint: |
@@ -687,43 +719,72 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
687 | 719 | ||
688 | /** | 720 | /** |
689 | * Contexts: | 721 | * Contexts: |
690 | * Statement returns DefaultDefinition | 722 | * AssertionOrDefinition.Assertion_1_0_0 returns Count |
691 | * DefaultDefinition returns DefaultDefinition | 723 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Count |
724 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Count | ||
725 | * Expression returns Count | ||
726 | * Expression.Forall_2_1_0 returns Count | ||
727 | * DisjunctiveExpression returns Count | ||
728 | * DisjunctiveExpression.Disjunction_1_0_0 returns Count | ||
729 | * DisjunctiveExpression.Case_1_1_0 returns Count | ||
730 | * ConjunctiveExpression returns Count | ||
731 | * ConjunctiveExpression.Conjunction_1_0 returns Count | ||
732 | * ComparisonExpression returns Count | ||
733 | * ComparisonExpression.BinaryExpression_1_0 returns Count | ||
734 | * AdditiveExpression returns Count | ||
735 | * AdditiveExpression.BinaryExpression_1_0 returns Count | ||
736 | * MultiplicativeExpression returns Count | ||
737 | * MultiplicativeExpression.BinaryExpression_1_0 returns Count | ||
738 | * ExponentialExpression returns Count | ||
739 | * ExponentialExpression.BinaryExpression_1_0 returns Count | ||
740 | * CastExpression returns Count | ||
741 | * CastExpression.CastExpression_1_0 returns Count | ||
742 | * UnaryExpression returns Count | ||
743 | * BracedAggregateExpression returns Count | ||
744 | * Count returns Count | ||
745 | * AtomicExpression returns Count | ||
692 | * | 746 | * |
693 | * Constraint: | 747 | * Constraint: |
694 | * (head=Call range=Expression) | 748 | * condition=Expression |
695 | */ | 749 | */ |
696 | protected void sequence_DefaultDefinition(ISerializationContext context, DefaultDefinition semanticObject) { | 750 | protected void sequence_Count(ISerializationContext context, Count semanticObject) { |
697 | if (errorAcceptor != null) { | 751 | if (errorAcceptor != null) { |
698 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD) == ValueTransient.YES) | 752 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) |
699 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD)); | 753 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); |
700 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE) == ValueTransient.YES) | ||
701 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE)); | ||
702 | } | 754 | } |
703 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 755 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
704 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | 756 | feeder.accept(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0(), semanticObject.getCondition()); |
705 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0(), semanticObject.getRange()); | ||
706 | feeder.finish(); | 757 | feeder.finish(); |
707 | } | 758 | } |
708 | 759 | ||
709 | 760 | ||
710 | /** | 761 | /** |
711 | * Contexts: | 762 | * Contexts: |
712 | * Statement returns Disjunction | 763 | * Statement returns DefaultAssertion |
713 | * AssertionOrDefinition returns Disjunction | 764 | * DefaultAssertion returns DefaultAssertion |
714 | * AssertionOrDefinition.Interpretation_1_0_0 returns Disjunction | 765 | * |
766 | * Constraint: | ||
767 | * (expression=Call range=Expression?) | ||
768 | */ | ||
769 | protected void sequence_DefaultAssertion(ISerializationContext context, DefaultAssertion semanticObject) { | ||
770 | genericSequencer.createSequence(context, semanticObject); | ||
771 | } | ||
772 | |||
773 | |||
774 | /** | ||
775 | * Contexts: | ||
776 | * AssertionOrDefinition.Assertion_1_0_0 returns Disjunction | ||
715 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction | 777 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction |
716 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Disjunction | 778 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Disjunction |
717 | * Expression returns Disjunction | 779 | * Expression returns Disjunction |
718 | * ImplicationExpression returns Disjunction | 780 | * Expression.Forall_2_1_0 returns Disjunction |
719 | * ImplicationExpression.BinaryExpression_1_0 returns Disjunction | ||
720 | * DisjunctiveExpression returns Disjunction | 781 | * DisjunctiveExpression returns Disjunction |
721 | * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction | 782 | * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction |
722 | * DisjunctiveExpression.Case_1_1_0 returns Disjunction | 783 | * DisjunctiveExpression.Case_1_1_0 returns Disjunction |
723 | * ConjunctiveExpression returns Disjunction | 784 | * ConjunctiveExpression returns Disjunction |
724 | * ConjunctiveExpression.Conjunction_1_0 returns Disjunction | 785 | * ConjunctiveExpression.Conjunction_1_0 returns Disjunction |
725 | * ComparisonExpression returns Disjunction | 786 | * ComparisonExpression returns Disjunction |
726 | * ComparisonExpression.Comparison_1_0 returns Disjunction | 787 | * ComparisonExpression.BinaryExpression_1_0 returns Disjunction |
727 | * AdditiveExpression returns Disjunction | 788 | * AdditiveExpression returns Disjunction |
728 | * AdditiveExpression.BinaryExpression_1_0 returns Disjunction | 789 | * AdditiveExpression.BinaryExpression_1_0 returns Disjunction |
729 | * MultiplicativeExpression returns Disjunction | 790 | * MultiplicativeExpression returns Disjunction |
@@ -733,7 +794,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
733 | * CastExpression returns Disjunction | 794 | * CastExpression returns Disjunction |
734 | * CastExpression.CastExpression_1_0 returns Disjunction | 795 | * CastExpression.CastExpression_1_0 returns Disjunction |
735 | * UnaryExpression returns Disjunction | 796 | * UnaryExpression returns Disjunction |
736 | * AggregationExpression returns Disjunction | 797 | * BracedAggregateExpression returns Disjunction |
737 | * AtomicExpression returns Disjunction | 798 | * AtomicExpression returns Disjunction |
738 | * | 799 | * |
739 | * Constraint: | 800 | * Constraint: |
@@ -746,21 +807,18 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
746 | 807 | ||
747 | /** | 808 | /** |
748 | * Contexts: | 809 | * Contexts: |
749 | * Statement returns Switch | 810 | * AssertionOrDefinition.Assertion_1_0_0 returns Switch |
750 | * AssertionOrDefinition returns Switch | ||
751 | * AssertionOrDefinition.Interpretation_1_0_0 returns Switch | ||
752 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch | 811 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch |
753 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Switch | 812 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Switch |
754 | * Expression returns Switch | 813 | * Expression returns Switch |
755 | * ImplicationExpression returns Switch | 814 | * Expression.Forall_2_1_0 returns Switch |
756 | * ImplicationExpression.BinaryExpression_1_0 returns Switch | ||
757 | * DisjunctiveExpression returns Switch | 815 | * DisjunctiveExpression returns Switch |
758 | * DisjunctiveExpression.Disjunction_1_0_0 returns Switch | 816 | * DisjunctiveExpression.Disjunction_1_0_0 returns Switch |
759 | * DisjunctiveExpression.Case_1_1_0 returns Switch | 817 | * DisjunctiveExpression.Case_1_1_0 returns Switch |
760 | * ConjunctiveExpression returns Switch | 818 | * ConjunctiveExpression returns Switch |
761 | * ConjunctiveExpression.Conjunction_1_0 returns Switch | 819 | * ConjunctiveExpression.Conjunction_1_0 returns Switch |
762 | * ComparisonExpression returns Switch | 820 | * ComparisonExpression returns Switch |
763 | * ComparisonExpression.Comparison_1_0 returns Switch | 821 | * ComparisonExpression.BinaryExpression_1_0 returns Switch |
764 | * AdditiveExpression returns Switch | 822 | * AdditiveExpression returns Switch |
765 | * AdditiveExpression.BinaryExpression_1_0 returns Switch | 823 | * AdditiveExpression.BinaryExpression_1_0 returns Switch |
766 | * MultiplicativeExpression returns Switch | 824 | * MultiplicativeExpression returns Switch |
@@ -770,7 +828,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
770 | * CastExpression returns Switch | 828 | * CastExpression returns Switch |
771 | * CastExpression.CastExpression_1_0 returns Switch | 829 | * CastExpression.CastExpression_1_0 returns Switch |
772 | * UnaryExpression returns Switch | 830 | * UnaryExpression returns Switch |
773 | * AggregationExpression returns Switch | 831 | * BracedAggregateExpression returns Switch |
774 | * AtomicExpression returns Switch | 832 | * AtomicExpression returns Switch |
775 | * | 833 | * |
776 | * Constraint: | 834 | * Constraint: |
@@ -804,81 +862,109 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
804 | 862 | ||
805 | /** | 863 | /** |
806 | * Contexts: | 864 | * Contexts: |
807 | * Statement returns EmptyIntervalLiteral | 865 | * AssertionOrDefinition.Assertion_1_0_0 returns EmptyLiteral |
808 | * AssertionOrDefinition returns EmptyIntervalLiteral | 866 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyLiteral |
809 | * AssertionOrDefinition.Interpretation_1_0_0 returns EmptyIntervalLiteral | 867 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns EmptyLiteral |
810 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyIntervalLiteral | 868 | * Expression returns EmptyLiteral |
811 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns EmptyIntervalLiteral | 869 | * Expression.Forall_2_1_0 returns EmptyLiteral |
812 | * Expression returns EmptyIntervalLiteral | 870 | * DisjunctiveExpression returns EmptyLiteral |
813 | * ImplicationExpression returns EmptyIntervalLiteral | 871 | * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyLiteral |
814 | * ImplicationExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | 872 | * DisjunctiveExpression.Case_1_1_0 returns EmptyLiteral |
815 | * DisjunctiveExpression returns EmptyIntervalLiteral | 873 | * ConjunctiveExpression returns EmptyLiteral |
816 | * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyIntervalLiteral | 874 | * ConjunctiveExpression.Conjunction_1_0 returns EmptyLiteral |
817 | * DisjunctiveExpression.Case_1_1_0 returns EmptyIntervalLiteral | 875 | * ComparisonExpression returns EmptyLiteral |
818 | * ConjunctiveExpression returns EmptyIntervalLiteral | 876 | * ComparisonExpression.BinaryExpression_1_0 returns EmptyLiteral |
819 | * ConjunctiveExpression.Conjunction_1_0 returns EmptyIntervalLiteral | 877 | * AdditiveExpression returns EmptyLiteral |
820 | * ComparisonExpression returns EmptyIntervalLiteral | 878 | * AdditiveExpression.BinaryExpression_1_0 returns EmptyLiteral |
821 | * ComparisonExpression.Comparison_1_0 returns EmptyIntervalLiteral | 879 | * MultiplicativeExpression returns EmptyLiteral |
822 | * AdditiveExpression returns EmptyIntervalLiteral | 880 | * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyLiteral |
823 | * AdditiveExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | 881 | * ExponentialExpression returns EmptyLiteral |
824 | * MultiplicativeExpression returns EmptyIntervalLiteral | 882 | * ExponentialExpression.BinaryExpression_1_0 returns EmptyLiteral |
825 | * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | 883 | * CastExpression returns EmptyLiteral |
826 | * ExponentialExpression returns EmptyIntervalLiteral | 884 | * CastExpression.CastExpression_1_0 returns EmptyLiteral |
827 | * ExponentialExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | 885 | * UnaryExpression returns EmptyLiteral |
828 | * CastExpression returns EmptyIntervalLiteral | 886 | * BracedAggregateExpression returns EmptyLiteral |
829 | * CastExpression.CastExpression_1_0 returns EmptyIntervalLiteral | 887 | * AtomicExpression returns EmptyLiteral |
830 | * UnaryExpression returns EmptyIntervalLiteral | 888 | * Literal returns EmptyLiteral |
831 | * AggregationExpression returns EmptyIntervalLiteral | 889 | * EmptyLiteral returns EmptyLiteral |
832 | * AtomicExpression returns EmptyIntervalLiteral | ||
833 | * Literal returns EmptyIntervalLiteral | ||
834 | * EmptyIntervalLiteral returns EmptyIntervalLiteral | ||
835 | * | 890 | * |
836 | * Constraint: | 891 | * Constraint: |
837 | * {EmptyIntervalLiteral} | 892 | * {EmptyLiteral} |
838 | */ | 893 | */ |
839 | protected void sequence_EmptyIntervalLiteral(ISerializationContext context, EmptyIntervalLiteral semanticObject) { | 894 | protected void sequence_EmptyLiteral(ISerializationContext context, EmptyLiteral semanticObject) { |
840 | genericSequencer.createSequence(context, semanticObject); | 895 | genericSequencer.createSequence(context, semanticObject); |
841 | } | 896 | } |
842 | 897 | ||
843 | 898 | ||
844 | /** | 899 | /** |
845 | * Contexts: | 900 | * Contexts: |
901 | * Statement returns EnumDeclaration | ||
902 | * EnumDeclaration returns EnumDeclaration | ||
903 | * | ||
904 | * Constraint: | ||
905 | * (name=ID (literals+=EnumLiteral literals+=EnumLiteral*)?) | ||
906 | */ | ||
907 | protected void sequence_EnumDeclaration(ISerializationContext context, EnumDeclaration semanticObject) { | ||
908 | genericSequencer.createSequence(context, semanticObject); | ||
909 | } | ||
910 | |||
911 | |||
912 | /** | ||
913 | * Contexts: | ||
914 | * EnumLiteral returns EnumLiteral | ||
915 | * | ||
916 | * Constraint: | ||
917 | * name=ID | ||
918 | */ | ||
919 | protected void sequence_EnumLiteral(ISerializationContext context, EnumLiteral semanticObject) { | ||
920 | if (errorAcceptor != null) { | ||
921 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ENUM_LITERAL__NAME) == ValueTransient.YES) | ||
922 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ENUM_LITERAL__NAME)); | ||
923 | } | ||
924 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
925 | feeder.accept(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | ||
926 | feeder.finish(); | ||
927 | } | ||
928 | |||
929 | |||
930 | /** | ||
931 | * Contexts: | ||
846 | * Multiplicity returns ExactMultiplicity | 932 | * Multiplicity returns ExactMultiplicity |
847 | * ExactMultiplicity returns ExactMultiplicity | 933 | * ExactMultiplicity returns ExactMultiplicity |
848 | * | 934 | * |
849 | * Constraint: | 935 | * Constraint: |
850 | * multiplicity=UpperMultiplicty | 936 | * value=UpperMultiplicty |
851 | */ | 937 | */ |
852 | protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { | 938 | protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { |
853 | if (errorAcceptor != null) { | 939 | if (errorAcceptor != null) { |
854 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY) == ValueTransient.YES) | 940 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__VALUE) == ValueTransient.YES) |
855 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY)); | 941 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__VALUE)); |
856 | } | 942 | } |
857 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 943 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
858 | feeder.accept(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0(), semanticObject.getMultiplicity()); | 944 | feeder.accept(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0(), semanticObject.getValue()); |
859 | feeder.finish(); | 945 | feeder.finish(); |
860 | } | 946 | } |
861 | 947 | ||
862 | 948 | ||
863 | /** | 949 | /** |
864 | * Contexts: | 950 | * Contexts: |
865 | * Statement returns ExactScopeDefinition | 951 | * Statement returns ExactScope |
866 | * ScopeDefinition returns ExactScopeDefinition | 952 | * ScopeDeclaration returns ExactScope |
867 | * ExactScopeDefinition returns ExactScopeDefinition | 953 | * ExactScope returns ExactScope |
868 | * | 954 | * |
869 | * Constraint: | 955 | * Constraint: |
870 | * (type=[NamedElement|QualifiedName] exactScope=INT) | 956 | * (type=[Symbol|QualifiedName] size=INT) |
871 | */ | 957 | */ |
872 | protected void sequence_ExactScopeDefinition(ISerializationContext context, ExactScopeDefinition semanticObject) { | 958 | protected void sequence_ExactScope(ISerializationContext context, ExactScope semanticObject) { |
873 | if (errorAcceptor != null) { | 959 | if (errorAcceptor != null) { |
874 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE) == ValueTransient.YES) | 960 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE) == ValueTransient.YES) |
875 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE)); | 961 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE)); |
876 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE) == ValueTransient.YES) | 962 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE__SIZE) == ValueTransient.YES) |
877 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE)); | 963 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE__SIZE)); |
878 | } | 964 | } |
879 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 965 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
880 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE, false)); | 966 | feeder.accept(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE, false)); |
881 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0(), semanticObject.getExactScope()); | 967 | feeder.accept(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0(), semanticObject.getSize()); |
882 | feeder.finish(); | 968 | feeder.finish(); |
883 | } | 969 | } |
884 | 970 | ||
@@ -889,171 +975,204 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
889 | * ExpressionArgument returns ExpressionArgument | 975 | * ExpressionArgument returns ExpressionArgument |
890 | * | 976 | * |
891 | * Constraint: | 977 | * Constraint: |
892 | * body=ComparisonExpression | 978 | * expression=ComparisonExpression |
893 | */ | 979 | */ |
894 | protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) { | 980 | protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) { |
895 | if (errorAcceptor != null) { | 981 | if (errorAcceptor != null) { |
896 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY) == ValueTransient.YES) | 982 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__EXPRESSION) == ValueTransient.YES) |
897 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY)); | 983 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__EXPRESSION)); |
898 | } | 984 | } |
899 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 985 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
900 | feeder.accept(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0(), semanticObject.getBody()); | 986 | feeder.accept(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0(), semanticObject.getExpression()); |
901 | feeder.finish(); | 987 | feeder.finish(); |
902 | } | 988 | } |
903 | 989 | ||
904 | 990 | ||
905 | /** | 991 | /** |
906 | * Contexts: | 992 | * Contexts: |
907 | * Statement returns ExternAggregatorDefinition | 993 | * AssertionOrDefinition.Assertion_1_0_0 returns Forall |
908 | * ExternAggregatorDefinition returns ExternAggregatorDefinition | 994 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Forall |
995 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Forall | ||
996 | * Expression returns Forall | ||
997 | * Expression.Forall_2_1_0 returns Forall | ||
998 | * DisjunctiveExpression returns Forall | ||
999 | * DisjunctiveExpression.Disjunction_1_0_0 returns Forall | ||
1000 | * DisjunctiveExpression.Case_1_1_0 returns Forall | ||
1001 | * ConjunctiveExpression returns Forall | ||
1002 | * ConjunctiveExpression.Conjunction_1_0 returns Forall | ||
1003 | * ComparisonExpression returns Forall | ||
1004 | * ComparisonExpression.BinaryExpression_1_0 returns Forall | ||
1005 | * AdditiveExpression returns Forall | ||
1006 | * AdditiveExpression.BinaryExpression_1_0 returns Forall | ||
1007 | * MultiplicativeExpression returns Forall | ||
1008 | * MultiplicativeExpression.BinaryExpression_1_0 returns Forall | ||
1009 | * ExponentialExpression returns Forall | ||
1010 | * ExponentialExpression.BinaryExpression_1_0 returns Forall | ||
1011 | * CastExpression returns Forall | ||
1012 | * CastExpression.CastExpression_1_0 returns Forall | ||
1013 | * UnaryExpression returns Forall | ||
1014 | * BracedAggregateExpression returns Forall | ||
1015 | * AtomicExpression returns Forall | ||
909 | * | 1016 | * |
910 | * Constraint: | 1017 | * Constraint: |
911 | * (type=[NamedElement|QualifiedName] name=QualifiedName inputType=[NamedElement|QualifiedName]) | 1018 | * (condition=Expression_Forall_2_1_0 body=DisjunctiveExpression) |
912 | */ | 1019 | */ |
913 | protected void sequence_ExternAggregatorDefinition(ISerializationContext context, ExternAggregatorDefinition semanticObject) { | 1020 | protected void sequence_Expression(ISerializationContext context, Forall semanticObject) { |
914 | if (errorAcceptor != null) { | 1021 | if (errorAcceptor != null) { |
915 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__TYPE) == ValueTransient.YES) | 1022 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) |
916 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__TYPE)); | 1023 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); |
917 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__NAME) == ValueTransient.YES) | 1024 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FORALL__BODY) == ValueTransient.YES) |
918 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__NAME)); | 1025 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FORALL__BODY)); |
919 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__INPUT_TYPE) == ValueTransient.YES) | ||
920 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__INPUT_TYPE)); | ||
921 | } | 1026 | } |
922 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1027 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
923 | feeder.accept(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__TYPE, false)); | 1028 | feeder.accept(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0(), semanticObject.getCondition()); |
924 | feeder.accept(grammarAccess.getExternAggregatorDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | 1029 | feeder.accept(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0(), semanticObject.getBody()); |
925 | feeder.accept(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementQualifiedNameParserRuleCall_4_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATOR_DEFINITION__INPUT_TYPE, false)); | ||
926 | feeder.finish(); | 1030 | feeder.finish(); |
927 | } | 1031 | } |
928 | 1032 | ||
929 | 1033 | ||
930 | /** | 1034 | /** |
931 | * Contexts: | 1035 | * Contexts: |
932 | * Statement returns ExternDatatypeDefinition | 1036 | * Statement returns ExternAggregationOperatorDeclaration |
933 | * ExternDatatypeDefinition returns ExternDatatypeDefinition | 1037 | * ExternDeclaration returns ExternAggregationOperatorDeclaration |
1038 | * ExternAggregationOperatorDeclaration returns ExternAggregationOperatorDeclaration | ||
934 | * | 1039 | * |
935 | * Constraint: | 1040 | * Constraint: |
936 | * (name=QualifiedName supertypes+=[NamedElement|QualifiedName] supertypes+=[NamedElement|QualifiedName]*) | 1041 | * (resultType=[Symbol|QualifiedName] name=QualifiedName argumentType=[Symbol|QualifiedName]) |
937 | */ | 1042 | */ |
938 | protected void sequence_ExternDatatypeDefinition(ISerializationContext context, ExternDatatypeDefinition semanticObject) { | 1043 | protected void sequence_ExternAggregationOperatorDeclaration(ISerializationContext context, ExternAggregationOperatorDeclaration semanticObject) { |
939 | genericSequencer.createSequence(context, semanticObject); | 1044 | if (errorAcceptor != null) { |
1045 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE) == ValueTransient.YES) | ||
1046 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE)); | ||
1047 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) | ||
1048 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); | ||
1049 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE) == ValueTransient.YES) | ||
1050 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE)); | ||
1051 | } | ||
1052 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1053 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE, false)); | ||
1054 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | ||
1055 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE, false)); | ||
1056 | feeder.finish(); | ||
940 | } | 1057 | } |
941 | 1058 | ||
942 | 1059 | ||
943 | /** | 1060 | /** |
944 | * Contexts: | 1061 | * Contexts: |
945 | * Statement returns ExternMetricDefinition | 1062 | * Statement returns ExternDatatypeDeclaration |
946 | * ExternMetricDefinition returns ExternMetricDefinition | 1063 | * ExternDeclaration returns ExternDatatypeDeclaration |
1064 | * ExternDatatypeDeclaration returns ExternDatatypeDeclaration | ||
947 | * | 1065 | * |
948 | * Constraint: | 1066 | * Constraint: |
949 | * (type=[NamedElement|QualifiedName] name=QualifiedName argumentList=ArgumentList) | 1067 | * name=QualifiedName |
950 | */ | 1068 | */ |
951 | protected void sequence_ExternMetricDefinition(ISerializationContext context, ExternMetricDefinition semanticObject) { | 1069 | protected void sequence_ExternDatatypeDeclaration(ISerializationContext context, ExternDatatypeDeclaration semanticObject) { |
952 | if (errorAcceptor != null) { | 1070 | if (errorAcceptor != null) { |
953 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE) == ValueTransient.YES) | 1071 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) |
954 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE)); | 1072 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); |
955 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__NAME) == ValueTransient.YES) | ||
956 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__NAME)); | ||
957 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES) | ||
958 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__ARGUMENT_LIST)); | ||
959 | } | 1073 | } |
960 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1074 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
961 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE, false)); | 1075 | feeder.accept(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); |
962 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | ||
963 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getArgumentListArgumentListParserRuleCall_3_0(), semanticObject.getArgumentList()); | ||
964 | feeder.finish(); | 1076 | feeder.finish(); |
965 | } | 1077 | } |
966 | 1078 | ||
967 | 1079 | ||
968 | /** | 1080 | /** |
969 | * Contexts: | 1081 | * Contexts: |
970 | * Statement returns ExternPredicateDefinition | 1082 | * Statement returns ExternFunctionDeclaration |
971 | * ExternPredicateDefinition returns ExternPredicateDefinition | 1083 | * ExternDeclaration returns ExternFunctionDeclaration |
1084 | * ExternFunctionDeclaration returns ExternFunctionDeclaration | ||
972 | * | 1085 | * |
973 | * Constraint: | 1086 | * Constraint: |
974 | * (name=QualifiedName argumentList=ArgumentList) | 1087 | * (resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList) |
975 | */ | 1088 | */ |
976 | protected void sequence_ExternPredicateDefinition(ISerializationContext context, ExternPredicateDefinition semanticObject) { | 1089 | protected void sequence_ExternFunctionDeclaration(ISerializationContext context, ExternFunctionDeclaration semanticObject) { |
977 | if (errorAcceptor != null) { | 1090 | if (errorAcceptor != null) { |
978 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__NAME) == ValueTransient.YES) | 1091 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE) == ValueTransient.YES) |
979 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__NAME)); | 1092 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE)); |
980 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES) | 1093 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) |
981 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__ARGUMENT_LIST)); | 1094 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); |
1095 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTOR_DECLARATION__ARGUMENT_LIST) == ValueTransient.YES) | ||
1096 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTOR_DECLARATION__ARGUMENT_LIST)); | ||
982 | } | 1097 | } |
983 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1098 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
984 | feeder.accept(grammarAccess.getExternPredicateDefinitionAccess().getNameQualifiedNameParserRuleCall_1_0(), semanticObject.getName()); | 1099 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE, false)); |
985 | feeder.accept(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListArgumentListParserRuleCall_2_0(), semanticObject.getArgumentList()); | 1100 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); |
1101 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0(), semanticObject.getArgumentList()); | ||
986 | feeder.finish(); | 1102 | feeder.finish(); |
987 | } | 1103 | } |
988 | 1104 | ||
989 | 1105 | ||
990 | /** | 1106 | /** |
991 | * Contexts: | 1107 | * Contexts: |
992 | * Statement returns IfElse | 1108 | * Statement returns ExternPredicateDeclaration |
993 | * AssertionOrDefinition returns IfElse | 1109 | * ExternDeclaration returns ExternPredicateDeclaration |
994 | * AssertionOrDefinition.Interpretation_1_0_0 returns IfElse | 1110 | * ExternPredicateDeclaration returns ExternPredicateDeclaration |
995 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IfElse | 1111 | * |
996 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns IfElse | 1112 | * Constraint: |
997 | * Expression returns IfElse | 1113 | * ((functional?='functional' | error?='error')* name=QualifiedName argumentList=ArgumentList) |
998 | * IfElse returns IfElse | 1114 | */ |
999 | * ImplicationExpression returns IfElse | 1115 | protected void sequence_ExternPredicateDeclaration(ISerializationContext context, ExternPredicateDeclaration semanticObject) { |
1000 | * ImplicationExpression.BinaryExpression_1_0 returns IfElse | 1116 | genericSequencer.createSequence(context, semanticObject); |
1001 | * DisjunctiveExpression returns IfElse | 1117 | } |
1002 | * DisjunctiveExpression.Disjunction_1_0_0 returns IfElse | 1118 | |
1003 | * DisjunctiveExpression.Case_1_1_0 returns IfElse | 1119 | |
1004 | * ConjunctiveExpression returns IfElse | 1120 | /** |
1005 | * ConjunctiveExpression.Conjunction_1_0 returns IfElse | 1121 | * Contexts: |
1006 | * ComparisonExpression returns IfElse | 1122 | * Field returns Field |
1007 | * ComparisonExpression.Comparison_1_0 returns IfElse | 1123 | * |
1008 | * AdditiveExpression returns IfElse | 1124 | * Constraint: |
1009 | * AdditiveExpression.BinaryExpression_1_0 returns IfElse | 1125 | * ( |
1010 | * MultiplicativeExpression returns IfElse | 1126 | * (containment?='contains' | crossReference?='refers')? |
1011 | * MultiplicativeExpression.BinaryExpression_1_0 returns IfElse | 1127 | * type=[Symbol|QualifiedName] |
1012 | * ExponentialExpression returns IfElse | 1128 | * multiplicity=Multiplicity? |
1013 | * ExponentialExpression.BinaryExpression_1_0 returns IfElse | 1129 | * name=ID |
1014 | * CastExpression returns IfElse | 1130 | * opposite=[Symbol|QualifiedName]? |
1015 | * CastExpression.CastExpression_1_0 returns IfElse | 1131 | * ) |
1016 | * UnaryExpression returns IfElse | 1132 | */ |
1017 | * AggregationExpression returns IfElse | 1133 | protected void sequence_Field(ISerializationContext context, Field semanticObject) { |
1018 | * AtomicExpression returns IfElse | 1134 | genericSequencer.createSequence(context, semanticObject); |
1135 | } | ||
1136 | |||
1137 | |||
1138 | /** | ||
1139 | * Contexts: | ||
1140 | * FunctionDefinition returns FunctionDefinition | ||
1019 | * | 1141 | * |
1020 | * Constraint: | 1142 | * Constraint: |
1021 | * (condition=Expression then=Expression else=Expression) | 1143 | * (resultType=[Symbol|QualifiedName] head=Call body=Expression) |
1022 | */ | 1144 | */ |
1023 | protected void sequence_IfElse(ISerializationContext context, IfElse semanticObject) { | 1145 | protected void sequence_FunctionDefinition(ISerializationContext context, FunctionDefinition semanticObject) { |
1024 | if (errorAcceptor != null) { | 1146 | if (errorAcceptor != null) { |
1025 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION) == ValueTransient.YES) | 1147 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE) == ValueTransient.YES) |
1026 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION)); | 1148 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE)); |
1027 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN) == ValueTransient.YES) | 1149 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) |
1028 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN)); | 1150 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); |
1029 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE) == ValueTransient.YES) | 1151 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) |
1030 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE)); | 1152 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); |
1031 | } | 1153 | } |
1032 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1154 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1033 | feeder.accept(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition()); | 1155 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE, false)); |
1034 | feeder.accept(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen()); | 1156 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); |
1035 | feeder.accept(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse()); | 1157 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); |
1036 | feeder.finish(); | 1158 | feeder.finish(); |
1037 | } | 1159 | } |
1038 | 1160 | ||
1039 | 1161 | ||
1040 | /** | 1162 | /** |
1041 | * Contexts: | 1163 | * Contexts: |
1042 | * Statement returns InfinityLiteral | 1164 | * AssertionOrDefinition.Assertion_1_0_0 returns InfinityLiteral |
1043 | * AssertionOrDefinition returns InfinityLiteral | ||
1044 | * AssertionOrDefinition.Interpretation_1_0_0 returns InfinityLiteral | ||
1045 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral | 1165 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral |
1046 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns InfinityLiteral | 1166 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns InfinityLiteral |
1047 | * Expression returns InfinityLiteral | 1167 | * Expression returns InfinityLiteral |
1048 | * ImplicationExpression returns InfinityLiteral | 1168 | * Expression.Forall_2_1_0 returns InfinityLiteral |
1049 | * ImplicationExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
1050 | * DisjunctiveExpression returns InfinityLiteral | 1169 | * DisjunctiveExpression returns InfinityLiteral |
1051 | * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral | 1170 | * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral |
1052 | * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral | 1171 | * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral |
1053 | * ConjunctiveExpression returns InfinityLiteral | 1172 | * ConjunctiveExpression returns InfinityLiteral |
1054 | * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral | 1173 | * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral |
1055 | * ComparisonExpression returns InfinityLiteral | 1174 | * ComparisonExpression returns InfinityLiteral |
1056 | * ComparisonExpression.Comparison_1_0 returns InfinityLiteral | 1175 | * ComparisonExpression.BinaryExpression_1_0 returns InfinityLiteral |
1057 | * AdditiveExpression returns InfinityLiteral | 1176 | * AdditiveExpression returns InfinityLiteral |
1058 | * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral | 1177 | * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral |
1059 | * MultiplicativeExpression returns InfinityLiteral | 1178 | * MultiplicativeExpression returns InfinityLiteral |
@@ -1063,7 +1182,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1063 | * CastExpression returns InfinityLiteral | 1182 | * CastExpression returns InfinityLiteral |
1064 | * CastExpression.CastExpression_1_0 returns InfinityLiteral | 1183 | * CastExpression.CastExpression_1_0 returns InfinityLiteral |
1065 | * UnaryExpression returns InfinityLiteral | 1184 | * UnaryExpression returns InfinityLiteral |
1066 | * AggregationExpression returns InfinityLiteral | 1185 | * BracedAggregateExpression returns InfinityLiteral |
1067 | * AtomicExpression returns InfinityLiteral | 1186 | * AtomicExpression returns InfinityLiteral |
1068 | * Literal returns InfinityLiteral | 1187 | * Literal returns InfinityLiteral |
1069 | * InfinityLiteral returns InfinityLiteral | 1188 | * InfinityLiteral returns InfinityLiteral |
@@ -1078,21 +1197,60 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1078 | 1197 | ||
1079 | /** | 1198 | /** |
1080 | * Contexts: | 1199 | * Contexts: |
1081 | * Statement returns Interval | 1200 | * AssertionOrDefinition.Assertion_1_0_0 returns IntLiteral |
1082 | * AssertionOrDefinition returns Interval | 1201 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IntLiteral |
1083 | * AssertionOrDefinition.Interpretation_1_0_0 returns Interval | 1202 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns IntLiteral |
1203 | * Expression returns IntLiteral | ||
1204 | * Expression.Forall_2_1_0 returns IntLiteral | ||
1205 | * DisjunctiveExpression returns IntLiteral | ||
1206 | * DisjunctiveExpression.Disjunction_1_0_0 returns IntLiteral | ||
1207 | * DisjunctiveExpression.Case_1_1_0 returns IntLiteral | ||
1208 | * ConjunctiveExpression returns IntLiteral | ||
1209 | * ConjunctiveExpression.Conjunction_1_0 returns IntLiteral | ||
1210 | * ComparisonExpression returns IntLiteral | ||
1211 | * ComparisonExpression.BinaryExpression_1_0 returns IntLiteral | ||
1212 | * AdditiveExpression returns IntLiteral | ||
1213 | * AdditiveExpression.BinaryExpression_1_0 returns IntLiteral | ||
1214 | * MultiplicativeExpression returns IntLiteral | ||
1215 | * MultiplicativeExpression.BinaryExpression_1_0 returns IntLiteral | ||
1216 | * ExponentialExpression returns IntLiteral | ||
1217 | * ExponentialExpression.BinaryExpression_1_0 returns IntLiteral | ||
1218 | * CastExpression returns IntLiteral | ||
1219 | * CastExpression.CastExpression_1_0 returns IntLiteral | ||
1220 | * UnaryExpression returns IntLiteral | ||
1221 | * BracedAggregateExpression returns IntLiteral | ||
1222 | * AtomicExpression returns IntLiteral | ||
1223 | * Literal returns IntLiteral | ||
1224 | * IntLiteral returns IntLiteral | ||
1225 | * | ||
1226 | * Constraint: | ||
1227 | * value=INT | ||
1228 | */ | ||
1229 | protected void sequence_IntLiteral(ISerializationContext context, IntLiteral semanticObject) { | ||
1230 | if (errorAcceptor != null) { | ||
1231 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_LITERAL__VALUE) == ValueTransient.YES) | ||
1232 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_LITERAL__VALUE)); | ||
1233 | } | ||
1234 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1235 | feeder.accept(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue()); | ||
1236 | feeder.finish(); | ||
1237 | } | ||
1238 | |||
1239 | |||
1240 | /** | ||
1241 | * Contexts: | ||
1242 | * AssertionOrDefinition.Assertion_1_0_0 returns Interval | ||
1084 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval | 1243 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval |
1085 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Interval | 1244 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Interval |
1086 | * Expression returns Interval | 1245 | * Expression returns Interval |
1087 | * ImplicationExpression returns Interval | 1246 | * Expression.Forall_2_1_0 returns Interval |
1088 | * ImplicationExpression.BinaryExpression_1_0 returns Interval | ||
1089 | * DisjunctiveExpression returns Interval | 1247 | * DisjunctiveExpression returns Interval |
1090 | * DisjunctiveExpression.Disjunction_1_0_0 returns Interval | 1248 | * DisjunctiveExpression.Disjunction_1_0_0 returns Interval |
1091 | * DisjunctiveExpression.Case_1_1_0 returns Interval | 1249 | * DisjunctiveExpression.Case_1_1_0 returns Interval |
1092 | * ConjunctiveExpression returns Interval | 1250 | * ConjunctiveExpression returns Interval |
1093 | * ConjunctiveExpression.Conjunction_1_0 returns Interval | 1251 | * ConjunctiveExpression.Conjunction_1_0 returns Interval |
1094 | * ComparisonExpression returns Interval | 1252 | * ComparisonExpression returns Interval |
1095 | * ComparisonExpression.Comparison_1_0 returns Interval | 1253 | * ComparisonExpression.BinaryExpression_1_0 returns Interval |
1096 | * AdditiveExpression returns Interval | 1254 | * AdditiveExpression returns Interval |
1097 | * AdditiveExpression.BinaryExpression_1_0 returns Interval | 1255 | * AdditiveExpression.BinaryExpression_1_0 returns Interval |
1098 | * MultiplicativeExpression returns Interval | 1256 | * MultiplicativeExpression returns Interval |
@@ -1102,12 +1260,12 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1102 | * CastExpression returns Interval | 1260 | * CastExpression returns Interval |
1103 | * CastExpression.CastExpression_1_0 returns Interval | 1261 | * CastExpression.CastExpression_1_0 returns Interval |
1104 | * UnaryExpression returns Interval | 1262 | * UnaryExpression returns Interval |
1105 | * AggregationExpression returns Interval | 1263 | * BracedAggregateExpression returns Interval |
1106 | * AtomicExpression returns Interval | 1264 | * AtomicExpression returns Interval |
1107 | * Interval returns Interval | 1265 | * Interval returns Interval |
1108 | * | 1266 | * |
1109 | * Constraint: | 1267 | * Constraint: |
1110 | * (lowerBound=Expression upperBound=Expression) | 1268 | * (lowerBound=AdditiveExpression upperBound=AdditiveExpression) |
1111 | */ | 1269 | */ |
1112 | protected void sequence_Interval(ISerializationContext context, Interval semanticObject) { | 1270 | protected void sequence_Interval(ISerializationContext context, Interval semanticObject) { |
1113 | if (errorAcceptor != null) { | 1271 | if (errorAcceptor != null) { |
@@ -1117,8 +1275,8 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1117 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND)); | 1275 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND)); |
1118 | } | 1276 | } |
1119 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1277 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1120 | feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0(), semanticObject.getLowerBound()); | 1278 | feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0(), semanticObject.getLowerBound()); |
1121 | feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0(), semanticObject.getUpperBound()); | 1279 | feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0(), semanticObject.getUpperBound()); |
1122 | feeder.finish(); | 1280 | feeder.finish(); |
1123 | } | 1281 | } |
1124 | 1282 | ||
@@ -1128,89 +1286,62 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1128 | * LetBinding returns LetBinding | 1286 | * LetBinding returns LetBinding |
1129 | * | 1287 | * |
1130 | * Constraint: | 1288 | * Constraint: |
1131 | * (variable=Variable value=AdditiveExpression) | 1289 | * (type=[Symbol|QualifiedName]? name=ID value=AdditiveExpression) |
1132 | */ | 1290 | */ |
1133 | protected void sequence_LetBinding(ISerializationContext context, LetBinding semanticObject) { | 1291 | protected void sequence_LetBinding(ISerializationContext context, LetBinding semanticObject) { |
1134 | if (errorAcceptor != null) { | ||
1135 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LET_BINDING__VARIABLE) == ValueTransient.YES) | ||
1136 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LET_BINDING__VARIABLE)); | ||
1137 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LET_BINDING__VALUE) == ValueTransient.YES) | ||
1138 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LET_BINDING__VALUE)); | ||
1139 | } | ||
1140 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1141 | feeder.accept(grammarAccess.getLetBindingAccess().getVariableVariableParserRuleCall_0_0(), semanticObject.getVariable()); | ||
1142 | feeder.accept(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_2_0(), semanticObject.getValue()); | ||
1143 | feeder.finish(); | ||
1144 | } | ||
1145 | |||
1146 | |||
1147 | /** | ||
1148 | * Contexts: | ||
1149 | * Statement returns Let | ||
1150 | * AssertionOrDefinition returns Let | ||
1151 | * AssertionOrDefinition.Interpretation_1_0_0 returns Let | ||
1152 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Let | ||
1153 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Let | ||
1154 | * Expression returns Let | ||
1155 | * Let returns Let | ||
1156 | * ImplicationExpression returns Let | ||
1157 | * ImplicationExpression.BinaryExpression_1_0 returns Let | ||
1158 | * DisjunctiveExpression returns Let | ||
1159 | * DisjunctiveExpression.Disjunction_1_0_0 returns Let | ||
1160 | * DisjunctiveExpression.Case_1_1_0 returns Let | ||
1161 | * ConjunctiveExpression returns Let | ||
1162 | * ConjunctiveExpression.Conjunction_1_0 returns Let | ||
1163 | * ComparisonExpression returns Let | ||
1164 | * ComparisonExpression.Comparison_1_0 returns Let | ||
1165 | * AdditiveExpression returns Let | ||
1166 | * AdditiveExpression.BinaryExpression_1_0 returns Let | ||
1167 | * MultiplicativeExpression returns Let | ||
1168 | * MultiplicativeExpression.BinaryExpression_1_0 returns Let | ||
1169 | * ExponentialExpression returns Let | ||
1170 | * ExponentialExpression.BinaryExpression_1_0 returns Let | ||
1171 | * CastExpression returns Let | ||
1172 | * CastExpression.CastExpression_1_0 returns Let | ||
1173 | * UnaryExpression returns Let | ||
1174 | * AggregationExpression returns Let | ||
1175 | * AtomicExpression returns Let | ||
1176 | * | ||
1177 | * Constraint: | ||
1178 | * (bindings+=LetBinding bindings+=LetBinding* body=Expression) | ||
1179 | */ | ||
1180 | protected void sequence_Let(ISerializationContext context, Let semanticObject) { | ||
1181 | genericSequencer.createSequence(context, semanticObject); | 1292 | genericSequencer.createSequence(context, semanticObject); |
1182 | } | 1293 | } |
1183 | 1294 | ||
1184 | 1295 | ||
1185 | /** | 1296 | /** |
1186 | * Contexts: | 1297 | * Contexts: |
1187 | * LocalVariables returns LocalVariables | 1298 | * AssertionOrDefinition.Assertion_1_0_0 returns LetExpression |
1299 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LetExpression | ||
1300 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns LetExpression | ||
1301 | * Expression returns LetExpression | ||
1302 | * Expression.Forall_2_1_0 returns LetExpression | ||
1303 | * LetExpression returns LetExpression | ||
1304 | * DisjunctiveExpression returns LetExpression | ||
1305 | * DisjunctiveExpression.Disjunction_1_0_0 returns LetExpression | ||
1306 | * DisjunctiveExpression.Case_1_1_0 returns LetExpression | ||
1307 | * ConjunctiveExpression returns LetExpression | ||
1308 | * ConjunctiveExpression.Conjunction_1_0 returns LetExpression | ||
1309 | * ComparisonExpression returns LetExpression | ||
1310 | * ComparisonExpression.BinaryExpression_1_0 returns LetExpression | ||
1311 | * AdditiveExpression returns LetExpression | ||
1312 | * AdditiveExpression.BinaryExpression_1_0 returns LetExpression | ||
1313 | * MultiplicativeExpression returns LetExpression | ||
1314 | * MultiplicativeExpression.BinaryExpression_1_0 returns LetExpression | ||
1315 | * ExponentialExpression returns LetExpression | ||
1316 | * ExponentialExpression.BinaryExpression_1_0 returns LetExpression | ||
1317 | * CastExpression returns LetExpression | ||
1318 | * CastExpression.CastExpression_1_0 returns LetExpression | ||
1319 | * UnaryExpression returns LetExpression | ||
1320 | * BracedAggregateExpression returns LetExpression | ||
1321 | * AtomicExpression returns LetExpression | ||
1188 | * | 1322 | * |
1189 | * Constraint: | 1323 | * Constraint: |
1190 | * (variables+=Variable variables+=Variable*)? | 1324 | * (bindings+=LetBinding bindings+=LetBinding* body=Expression) |
1191 | */ | 1325 | */ |
1192 | protected void sequence_LocalVariables(ISerializationContext context, LocalVariables semanticObject) { | 1326 | protected void sequence_LetExpression(ISerializationContext context, LetExpression semanticObject) { |
1193 | genericSequencer.createSequence(context, semanticObject); | 1327 | genericSequencer.createSequence(context, semanticObject); |
1194 | } | 1328 | } |
1195 | 1329 | ||
1196 | 1330 | ||
1197 | /** | 1331 | /** |
1198 | * Contexts: | 1332 | * Contexts: |
1199 | * Statement returns LogicLiteral | 1333 | * AssertionOrDefinition.Assertion_1_0_0 returns LogicLiteral |
1200 | * AssertionOrDefinition returns LogicLiteral | ||
1201 | * AssertionOrDefinition.Interpretation_1_0_0 returns LogicLiteral | ||
1202 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral | 1334 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral |
1203 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns LogicLiteral | 1335 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns LogicLiteral |
1204 | * Expression returns LogicLiteral | 1336 | * Expression returns LogicLiteral |
1205 | * ImplicationExpression returns LogicLiteral | 1337 | * Expression.Forall_2_1_0 returns LogicLiteral |
1206 | * ImplicationExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1207 | * DisjunctiveExpression returns LogicLiteral | 1338 | * DisjunctiveExpression returns LogicLiteral |
1208 | * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral | 1339 | * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral |
1209 | * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral | 1340 | * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral |
1210 | * ConjunctiveExpression returns LogicLiteral | 1341 | * ConjunctiveExpression returns LogicLiteral |
1211 | * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral | 1342 | * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral |
1212 | * ComparisonExpression returns LogicLiteral | 1343 | * ComparisonExpression returns LogicLiteral |
1213 | * ComparisonExpression.Comparison_1_0 returns LogicLiteral | 1344 | * ComparisonExpression.BinaryExpression_1_0 returns LogicLiteral |
1214 | * AdditiveExpression returns LogicLiteral | 1345 | * AdditiveExpression returns LogicLiteral |
1215 | * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral | 1346 | * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral |
1216 | * MultiplicativeExpression returns LogicLiteral | 1347 | * MultiplicativeExpression returns LogicLiteral |
@@ -1220,7 +1351,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1220 | * CastExpression returns LogicLiteral | 1351 | * CastExpression returns LogicLiteral |
1221 | * CastExpression.CastExpression_1_0 returns LogicLiteral | 1352 | * CastExpression.CastExpression_1_0 returns LogicLiteral |
1222 | * UnaryExpression returns LogicLiteral | 1353 | * UnaryExpression returns LogicLiteral |
1223 | * AggregationExpression returns LogicLiteral | 1354 | * BracedAggregateExpression returns LogicLiteral |
1224 | * AtomicExpression returns LogicLiteral | 1355 | * AtomicExpression returns LogicLiteral |
1225 | * Literal returns LogicLiteral | 1356 | * Literal returns LogicLiteral |
1226 | * LogicLiteral returns LogicLiteral | 1357 | * LogicLiteral returns LogicLiteral |
@@ -1241,131 +1372,75 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1241 | 1372 | ||
1242 | /** | 1373 | /** |
1243 | * Contexts: | 1374 | * Contexts: |
1244 | * Statement returns LowerBoundedScopeDefinition | 1375 | * Statement returns LowerBoundedScope |
1245 | * ScopeDefinition returns LowerBoundedScopeDefinition | 1376 | * ScopeDeclaration returns LowerBoundedScope |
1246 | * LowerBoundedScopeDefinition returns LowerBoundedScopeDefinition | 1377 | * LowerBoundedScope returns LowerBoundedScope |
1247 | * | ||
1248 | * Constraint: | ||
1249 | * ((lowerBound=INT type=[NamedElement|QualifiedName]) | (type=[NamedElement|QualifiedName] lowerBound=INT)) | ||
1250 | */ | ||
1251 | protected void sequence_LowerBoundedScopeDefinition(ISerializationContext context, LowerBoundedScopeDefinition semanticObject) { | ||
1252 | genericSequencer.createSequence(context, semanticObject); | ||
1253 | } | ||
1254 | |||
1255 | |||
1256 | /** | ||
1257 | * Contexts: | ||
1258 | * Multiplicity returns ManyMultiplicity | ||
1259 | * ManyMultiplicity returns ManyMultiplicity | ||
1260 | * | 1378 | * |
1261 | * Constraint: | 1379 | * Constraint: |
1262 | * {ManyMultiplicity} | 1380 | * ((lowerBound=INT type=[Symbol|QualifiedName]) | (type=[Symbol|QualifiedName] lowerBound=INT)) |
1263 | */ | 1381 | */ |
1264 | protected void sequence_ManyMultiplicity(ISerializationContext context, ManyMultiplicity semanticObject) { | 1382 | protected void sequence_LowerBoundedScope(ISerializationContext context, LowerBoundedScope semanticObject) { |
1265 | genericSequencer.createSequence(context, semanticObject); | 1383 | genericSequencer.createSequence(context, semanticObject); |
1266 | } | 1384 | } |
1267 | 1385 | ||
1268 | 1386 | ||
1269 | /** | 1387 | /** |
1270 | * Contexts: | 1388 | * Contexts: |
1271 | * MemberDefinition returns MemberDefinition | 1389 | * Import returns NamespaceImport |
1390 | * NamespaceImport returns NamespaceImport | ||
1272 | * | 1391 | * |
1273 | * Constraint: | 1392 | * Constraint: |
1274 | * (containment?='contains'? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID opposite=[NamedElement|QualifiedName]?) | 1393 | * (importedNamespace=QualifiedName alias=QualifiedName) |
1275 | */ | 1394 | */ |
1276 | protected void sequence_MemberDefinition(ISerializationContext context, MemberDefinition semanticObject) { | 1395 | protected void sequence_NamespaceImport(ISerializationContext context, NamespaceImport semanticObject) { |
1277 | genericSequencer.createSequence(context, semanticObject); | ||
1278 | } | ||
1279 | |||
1280 | |||
1281 | /** | ||
1282 | * Contexts: | ||
1283 | * MetricDefinition returns MetricDefinition | ||
1284 | * | ||
1285 | * Constraint: | ||
1286 | * (type=[NamedElement|QualifiedName] head=Call body=Expression) | ||
1287 | */ | ||
1288 | protected void sequence_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { | ||
1289 | if (errorAcceptor != null) { | 1396 | if (errorAcceptor != null) { |
1290 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE) == ValueTransient.YES) | 1397 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMESPACE_IMPORT__IMPORTED_NAMESPACE) == ValueTransient.YES) |
1291 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE)); | 1398 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMESPACE_IMPORT__IMPORTED_NAMESPACE)); |
1292 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) | 1399 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS) == ValueTransient.YES) |
1293 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); | 1400 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS)); |
1294 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | ||
1295 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | ||
1296 | } | 1401 | } |
1297 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1402 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1298 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE, false)); | 1403 | feeder.accept(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0(), semanticObject.getImportedNamespace()); |
1299 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | 1404 | feeder.accept(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0(), semanticObject.getAlias()); |
1300 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
1301 | feeder.finish(); | 1405 | feeder.finish(); |
1302 | } | 1406 | } |
1303 | 1407 | ||
1304 | 1408 | ||
1305 | /** | 1409 | /** |
1306 | * Contexts: | 1410 | * Contexts: |
1307 | * Statement returns NumericLiteral | 1411 | * Statement returns ObjectiveDeclaration |
1308 | * AssertionOrDefinition returns NumericLiteral | 1412 | * ObjectiveDeclaration returns ObjectiveDeclaration |
1309 | * AssertionOrDefinition.Interpretation_1_0_0 returns NumericLiteral | ||
1310 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns NumericLiteral | ||
1311 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns NumericLiteral | ||
1312 | * Expression returns NumericLiteral | ||
1313 | * ImplicationExpression returns NumericLiteral | ||
1314 | * ImplicationExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1315 | * DisjunctiveExpression returns NumericLiteral | ||
1316 | * DisjunctiveExpression.Disjunction_1_0_0 returns NumericLiteral | ||
1317 | * DisjunctiveExpression.Case_1_1_0 returns NumericLiteral | ||
1318 | * ConjunctiveExpression returns NumericLiteral | ||
1319 | * ConjunctiveExpression.Conjunction_1_0 returns NumericLiteral | ||
1320 | * ComparisonExpression returns NumericLiteral | ||
1321 | * ComparisonExpression.Comparison_1_0 returns NumericLiteral | ||
1322 | * AdditiveExpression returns NumericLiteral | ||
1323 | * AdditiveExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1324 | * MultiplicativeExpression returns NumericLiteral | ||
1325 | * MultiplicativeExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1326 | * ExponentialExpression returns NumericLiteral | ||
1327 | * ExponentialExpression.BinaryExpression_1_0 returns NumericLiteral | ||
1328 | * CastExpression returns NumericLiteral | ||
1329 | * CastExpression.CastExpression_1_0 returns NumericLiteral | ||
1330 | * UnaryExpression returns NumericLiteral | ||
1331 | * AggregationExpression returns NumericLiteral | ||
1332 | * AtomicExpression returns NumericLiteral | ||
1333 | * Literal returns NumericLiteral | ||
1334 | * NumericLiteral returns NumericLiteral | ||
1335 | * | 1413 | * |
1336 | * Constraint: | 1414 | * Constraint: |
1337 | * value=Real | 1415 | * (kind=ObjectiveKind objective=Expression) |
1338 | */ | 1416 | */ |
1339 | protected void sequence_NumericLiteral(ISerializationContext context, NumericLiteral semanticObject) { | 1417 | protected void sequence_ObjectiveDeclaration(ISerializationContext context, ObjectiveDeclaration semanticObject) { |
1340 | if (errorAcceptor != null) { | 1418 | if (errorAcceptor != null) { |
1341 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE) == ValueTransient.YES) | 1419 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__KIND) == ValueTransient.YES) |
1342 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE)); | 1420 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__KIND)); |
1421 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__OBJECTIVE) == ValueTransient.YES) | ||
1422 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__OBJECTIVE)); | ||
1343 | } | 1423 | } |
1344 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1424 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1345 | feeder.accept(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue()); | 1425 | feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind()); |
1426 | feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective()); | ||
1346 | feeder.finish(); | 1427 | feeder.finish(); |
1347 | } | 1428 | } |
1348 | 1429 | ||
1349 | 1430 | ||
1350 | /** | 1431 | /** |
1351 | * Contexts: | 1432 | * Contexts: |
1352 | * Statement returns ObjectiveDefinition | 1433 | * PathComponent returns PathComponent |
1353 | * ObjectiveDefinition returns ObjectiveDefinition | ||
1354 | * | 1434 | * |
1355 | * Constraint: | 1435 | * Constraint: |
1356 | * (kind=ObjectiveKind objective=Expression) | 1436 | * ( |
1437 | * inverse?='~'? | ||
1438 | * symbol=[Symbol|QualifiedName] | ||
1439 | * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
1440 | * ) | ||
1357 | */ | 1441 | */ |
1358 | protected void sequence_ObjectiveDefinition(ISerializationContext context, ObjectiveDefinition semanticObject) { | 1442 | protected void sequence_PathComponent(ISerializationContext context, PathComponent semanticObject) { |
1359 | if (errorAcceptor != null) { | 1443 | genericSequencer.createSequence(context, semanticObject); |
1360 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND) == ValueTransient.YES) | ||
1361 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND)); | ||
1362 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE) == ValueTransient.YES) | ||
1363 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE)); | ||
1364 | } | ||
1365 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1366 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
1367 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective()); | ||
1368 | feeder.finish(); | ||
1369 | } | 1444 | } |
1370 | 1445 | ||
1371 | 1446 | ||
@@ -1386,7 +1461,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1386 | * Problem returns Problem | 1461 | * Problem returns Problem |
1387 | * | 1462 | * |
1388 | * Constraint: | 1463 | * Constraint: |
1389 | * statements+=Statement+ | 1464 | * ((name=QualifiedName? imports+=Import+ statements+=Statement+) | (name=QualifiedName? statements+=Statement+) | statements+=Statement+)? |
1390 | */ | 1465 | */ |
1391 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { | 1466 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { |
1392 | genericSequencer.createSequence(context, semanticObject); | 1467 | genericSequencer.createSequence(context, semanticObject); |
@@ -1395,59 +1470,60 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1395 | 1470 | ||
1396 | /** | 1471 | /** |
1397 | * Contexts: | 1472 | * Contexts: |
1398 | * Statement returns QuantifiedExpression | 1473 | * AssertionOrDefinition.Assertion_1_0_0 returns RealLiteral |
1399 | * AssertionOrDefinition returns QuantifiedExpression | 1474 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns RealLiteral |
1400 | * AssertionOrDefinition.Interpretation_1_0_0 returns QuantifiedExpression | 1475 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns RealLiteral |
1401 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns QuantifiedExpression | 1476 | * Expression returns RealLiteral |
1402 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns QuantifiedExpression | 1477 | * Expression.Forall_2_1_0 returns RealLiteral |
1403 | * Expression returns QuantifiedExpression | 1478 | * DisjunctiveExpression returns RealLiteral |
1404 | * ImplicationExpression returns QuantifiedExpression | 1479 | * DisjunctiveExpression.Disjunction_1_0_0 returns RealLiteral |
1405 | * ImplicationExpression.BinaryExpression_1_0 returns QuantifiedExpression | 1480 | * DisjunctiveExpression.Case_1_1_0 returns RealLiteral |
1406 | * DisjunctiveExpression returns QuantifiedExpression | 1481 | * ConjunctiveExpression returns RealLiteral |
1407 | * DisjunctiveExpression.Disjunction_1_0_0 returns QuantifiedExpression | 1482 | * ConjunctiveExpression.Conjunction_1_0 returns RealLiteral |
1408 | * DisjunctiveExpression.Case_1_1_0 returns QuantifiedExpression | 1483 | * ComparisonExpression returns RealLiteral |
1409 | * ConjunctiveExpression returns QuantifiedExpression | 1484 | * ComparisonExpression.BinaryExpression_1_0 returns RealLiteral |
1410 | * ConjunctiveExpression.Conjunction_1_0 returns QuantifiedExpression | 1485 | * AdditiveExpression returns RealLiteral |
1411 | * ComparisonExpression returns QuantifiedExpression | 1486 | * AdditiveExpression.BinaryExpression_1_0 returns RealLiteral |
1412 | * ComparisonExpression.Comparison_1_0 returns QuantifiedExpression | 1487 | * MultiplicativeExpression returns RealLiteral |
1413 | * AdditiveExpression returns QuantifiedExpression | 1488 | * MultiplicativeExpression.BinaryExpression_1_0 returns RealLiteral |
1414 | * AdditiveExpression.BinaryExpression_1_0 returns QuantifiedExpression | 1489 | * ExponentialExpression returns RealLiteral |
1415 | * MultiplicativeExpression returns QuantifiedExpression | 1490 | * ExponentialExpression.BinaryExpression_1_0 returns RealLiteral |
1416 | * MultiplicativeExpression.BinaryExpression_1_0 returns QuantifiedExpression | 1491 | * CastExpression returns RealLiteral |
1417 | * ExponentialExpression returns QuantifiedExpression | 1492 | * CastExpression.CastExpression_1_0 returns RealLiteral |
1418 | * ExponentialExpression.BinaryExpression_1_0 returns QuantifiedExpression | 1493 | * UnaryExpression returns RealLiteral |
1419 | * CastExpression returns QuantifiedExpression | 1494 | * BracedAggregateExpression returns RealLiteral |
1420 | * CastExpression.CastExpression_1_0 returns QuantifiedExpression | 1495 | * AtomicExpression returns RealLiteral |
1421 | * UnaryExpression returns QuantifiedExpression | 1496 | * Literal returns RealLiteral |
1422 | * AggregationExpression returns QuantifiedExpression | 1497 | * RealLiteral returns RealLiteral |
1423 | * QuantifiedExpression returns QuantifiedExpression | ||
1424 | * AtomicExpression returns QuantifiedExpression | ||
1425 | * | 1498 | * |
1426 | * Constraint: | 1499 | * Constraint: |
1427 | * (quantifier=Quantifier localVariables=LocalVariables? body=Expression) | 1500 | * value=Real |
1428 | */ | 1501 | */ |
1429 | protected void sequence_QuantifiedExpression(ISerializationContext context, QuantifiedExpression semanticObject) { | 1502 | protected void sequence_RealLiteral(ISerializationContext context, RealLiteral semanticObject) { |
1430 | genericSequencer.createSequence(context, semanticObject); | 1503 | if (errorAcceptor != null) { |
1504 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_LITERAL__VALUE) == ValueTransient.YES) | ||
1505 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_LITERAL__VALUE)); | ||
1506 | } | ||
1507 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1508 | feeder.accept(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue()); | ||
1509 | feeder.finish(); | ||
1431 | } | 1510 | } |
1432 | 1511 | ||
1433 | 1512 | ||
1434 | /** | 1513 | /** |
1435 | * Contexts: | 1514 | * Contexts: |
1436 | * Statement returns Reference | 1515 | * AssertionOrDefinition.Assertion_1_0_0 returns Reference |
1437 | * AssertionOrDefinition returns Reference | ||
1438 | * AssertionOrDefinition.Interpretation_1_0_0 returns Reference | ||
1439 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference | 1516 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference |
1440 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Reference | 1517 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Reference |
1441 | * Expression returns Reference | 1518 | * Expression returns Reference |
1442 | * ImplicationExpression returns Reference | 1519 | * Expression.Forall_2_1_0 returns Reference |
1443 | * ImplicationExpression.BinaryExpression_1_0 returns Reference | ||
1444 | * DisjunctiveExpression returns Reference | 1520 | * DisjunctiveExpression returns Reference |
1445 | * DisjunctiveExpression.Disjunction_1_0_0 returns Reference | 1521 | * DisjunctiveExpression.Disjunction_1_0_0 returns Reference |
1446 | * DisjunctiveExpression.Case_1_1_0 returns Reference | 1522 | * DisjunctiveExpression.Case_1_1_0 returns Reference |
1447 | * ConjunctiveExpression returns Reference | 1523 | * ConjunctiveExpression returns Reference |
1448 | * ConjunctiveExpression.Conjunction_1_0 returns Reference | 1524 | * ConjunctiveExpression.Conjunction_1_0 returns Reference |
1449 | * ComparisonExpression returns Reference | 1525 | * ComparisonExpression returns Reference |
1450 | * ComparisonExpression.Comparison_1_0 returns Reference | 1526 | * ComparisonExpression.BinaryExpression_1_0 returns Reference |
1451 | * AdditiveExpression returns Reference | 1527 | * AdditiveExpression returns Reference |
1452 | * AdditiveExpression.BinaryExpression_1_0 returns Reference | 1528 | * AdditiveExpression.BinaryExpression_1_0 returns Reference |
1453 | * MultiplicativeExpression returns Reference | 1529 | * MultiplicativeExpression returns Reference |
@@ -1457,21 +1533,15 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1457 | * CastExpression returns Reference | 1533 | * CastExpression returns Reference |
1458 | * CastExpression.CastExpression_1_0 returns Reference | 1534 | * CastExpression.CastExpression_1_0 returns Reference |
1459 | * UnaryExpression returns Reference | 1535 | * UnaryExpression returns Reference |
1460 | * AggregationExpression returns Reference | 1536 | * BracedAggregateExpression returns Reference |
1461 | * AtomicExpression returns Reference | 1537 | * AtomicExpression returns Reference |
1462 | * Reference returns Reference | 1538 | * Reference returns Reference |
1463 | * | 1539 | * |
1464 | * Constraint: | 1540 | * Constraint: |
1465 | * referred=[NamedElement|QualifiedName] | 1541 | * (components+=PathComponent components+=PathComponent*) |
1466 | */ | 1542 | */ |
1467 | protected void sequence_Reference(ISerializationContext context, Reference semanticObject) { | 1543 | protected void sequence_Reference(ISerializationContext context, Reference semanticObject) { |
1468 | if (errorAcceptor != null) { | 1544 | genericSequencer.createSequence(context, semanticObject); |
1469 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED) == ValueTransient.YES) | ||
1470 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED)); | ||
1471 | } | ||
1472 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1473 | feeder.accept(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.REFERENCE__REFERRED, false)); | ||
1474 | feeder.finish(); | ||
1475 | } | 1545 | } |
1476 | 1546 | ||
1477 | 1547 | ||
@@ -1490,21 +1560,18 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1490 | 1560 | ||
1491 | /** | 1561 | /** |
1492 | * Contexts: | 1562 | * Contexts: |
1493 | * Statement returns StringLiteral | 1563 | * AssertionOrDefinition.Assertion_1_0_0 returns StringLiteral |
1494 | * AssertionOrDefinition returns StringLiteral | ||
1495 | * AssertionOrDefinition.Interpretation_1_0_0 returns StringLiteral | ||
1496 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral | 1564 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral |
1497 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns StringLiteral | 1565 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns StringLiteral |
1498 | * Expression returns StringLiteral | 1566 | * Expression returns StringLiteral |
1499 | * ImplicationExpression returns StringLiteral | 1567 | * Expression.Forall_2_1_0 returns StringLiteral |
1500 | * ImplicationExpression.BinaryExpression_1_0 returns StringLiteral | ||
1501 | * DisjunctiveExpression returns StringLiteral | 1568 | * DisjunctiveExpression returns StringLiteral |
1502 | * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral | 1569 | * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral |
1503 | * DisjunctiveExpression.Case_1_1_0 returns StringLiteral | 1570 | * DisjunctiveExpression.Case_1_1_0 returns StringLiteral |
1504 | * ConjunctiveExpression returns StringLiteral | 1571 | * ConjunctiveExpression returns StringLiteral |
1505 | * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral | 1572 | * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral |
1506 | * ComparisonExpression returns StringLiteral | 1573 | * ComparisonExpression returns StringLiteral |
1507 | * ComparisonExpression.Comparison_1_0 returns StringLiteral | 1574 | * ComparisonExpression.BinaryExpression_1_0 returns StringLiteral |
1508 | * AdditiveExpression returns StringLiteral | 1575 | * AdditiveExpression returns StringLiteral |
1509 | * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral | 1576 | * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral |
1510 | * MultiplicativeExpression returns StringLiteral | 1577 | * MultiplicativeExpression returns StringLiteral |
@@ -1514,7 +1581,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1514 | * CastExpression returns StringLiteral | 1581 | * CastExpression returns StringLiteral |
1515 | * CastExpression.CastExpression_1_0 returns StringLiteral | 1582 | * CastExpression.CastExpression_1_0 returns StringLiteral |
1516 | * UnaryExpression returns StringLiteral | 1583 | * UnaryExpression returns StringLiteral |
1517 | * AggregationExpression returns StringLiteral | 1584 | * BracedAggregateExpression returns StringLiteral |
1518 | * AtomicExpression returns StringLiteral | 1585 | * AtomicExpression returns StringLiteral |
1519 | * Literal returns StringLiteral | 1586 | * Literal returns StringLiteral |
1520 | * StringLiteral returns StringLiteral | 1587 | * StringLiteral returns StringLiteral |
@@ -1535,62 +1602,71 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1535 | 1602 | ||
1536 | /** | 1603 | /** |
1537 | * Contexts: | 1604 | * Contexts: |
1538 | * Argument returns TypedArgument | 1605 | * TypeReference returns TypeReference |
1539 | * TypedArgument returns TypedArgument | 1606 | * |
1607 | * Constraint: | ||
1608 | * (type=[Symbol|QualifiedName] forceObjectType?='object'?) | ||
1609 | */ | ||
1610 | protected void sequence_TypeReference(ISerializationContext context, TypeReference semanticObject) { | ||
1611 | genericSequencer.createSequence(context, semanticObject); | ||
1612 | } | ||
1613 | |||
1614 | |||
1615 | /** | ||
1616 | * Contexts: | ||
1617 | * Argument returns TypedStarArgument | ||
1618 | * TypedStarArgument returns TypedStarArgument | ||
1540 | * | 1619 | * |
1541 | * Constraint: | 1620 | * Constraint: |
1542 | * (type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName]) | 1621 | * typeReference=TypeReference |
1543 | */ | 1622 | */ |
1544 | protected void sequence_TypedArgument(ISerializationContext context, TypedArgument semanticObject) { | 1623 | protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) { |
1545 | if (errorAcceptor != null) { | 1624 | if (errorAcceptor != null) { |
1546 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE) == ValueTransient.YES) | 1625 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE) == ValueTransient.YES) |
1547 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE)); | 1626 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE)); |
1548 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE) == ValueTransient.YES) | ||
1549 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE)); | ||
1550 | } | 1627 | } |
1551 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1628 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1552 | feeder.accept(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE, false)); | 1629 | feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0(), semanticObject.getTypeReference()); |
1553 | feeder.accept(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE, false)); | ||
1554 | feeder.finish(); | 1630 | feeder.finish(); |
1555 | } | 1631 | } |
1556 | 1632 | ||
1557 | 1633 | ||
1558 | /** | 1634 | /** |
1559 | * Contexts: | 1635 | * Contexts: |
1560 | * Argument returns TypedStarArgument | 1636 | * Argument returns TypedVariableArgument |
1561 | * TypedStarArgument returns TypedStarArgument | 1637 | * TypedVariableArgument returns TypedVariableArgument |
1562 | * | 1638 | * |
1563 | * Constraint: | 1639 | * Constraint: |
1564 | * type=[NamedElement|QualifiedName] | 1640 | * (typeReference=TypeReference name=ID) |
1565 | */ | 1641 | */ |
1566 | protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) { | 1642 | protected void sequence_TypedVariableArgument(ISerializationContext context, TypedVariableArgument semanticObject) { |
1567 | if (errorAcceptor != null) { | 1643 | if (errorAcceptor != null) { |
1568 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE) == ValueTransient.YES) | 1644 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE) == ValueTransient.YES) |
1569 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE)); | 1645 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE)); |
1646 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_VARIABLE_ARGUMENT__NAME) == ValueTransient.YES) | ||
1647 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_VARIABLE_ARGUMENT__NAME)); | ||
1570 | } | 1648 | } |
1571 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1649 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1572 | feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE, false)); | 1650 | feeder.accept(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0(), semanticObject.getTypeReference()); |
1651 | feeder.accept(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); | ||
1573 | feeder.finish(); | 1652 | feeder.finish(); |
1574 | } | 1653 | } |
1575 | 1654 | ||
1576 | 1655 | ||
1577 | /** | 1656 | /** |
1578 | * Contexts: | 1657 | * Contexts: |
1579 | * Statement returns UnaryExpression | 1658 | * AssertionOrDefinition.Assertion_1_0_0 returns UnaryExpression |
1580 | * AssertionOrDefinition returns UnaryExpression | ||
1581 | * AssertionOrDefinition.Interpretation_1_0_0 returns UnaryExpression | ||
1582 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression | 1659 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression |
1583 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns UnaryExpression | 1660 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns UnaryExpression |
1584 | * Expression returns UnaryExpression | 1661 | * Expression returns UnaryExpression |
1585 | * ImplicationExpression returns UnaryExpression | 1662 | * Expression.Forall_2_1_0 returns UnaryExpression |
1586 | * ImplicationExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1587 | * DisjunctiveExpression returns UnaryExpression | 1663 | * DisjunctiveExpression returns UnaryExpression |
1588 | * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression | 1664 | * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression |
1589 | * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression | 1665 | * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression |
1590 | * ConjunctiveExpression returns UnaryExpression | 1666 | * ConjunctiveExpression returns UnaryExpression |
1591 | * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression | 1667 | * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression |
1592 | * ComparisonExpression returns UnaryExpression | 1668 | * ComparisonExpression returns UnaryExpression |
1593 | * ComparisonExpression.Comparison_1_0 returns UnaryExpression | 1669 | * ComparisonExpression.BinaryExpression_1_0 returns UnaryExpression |
1594 | * AdditiveExpression returns UnaryExpression | 1670 | * AdditiveExpression returns UnaryExpression |
1595 | * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression | 1671 | * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression |
1596 | * MultiplicativeExpression returns UnaryExpression | 1672 | * MultiplicativeExpression returns UnaryExpression |
@@ -1600,11 +1676,11 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1600 | * CastExpression returns UnaryExpression | 1676 | * CastExpression returns UnaryExpression |
1601 | * CastExpression.CastExpression_1_0 returns UnaryExpression | 1677 | * CastExpression.CastExpression_1_0 returns UnaryExpression |
1602 | * UnaryExpression returns UnaryExpression | 1678 | * UnaryExpression returns UnaryExpression |
1603 | * AggregationExpression returns UnaryExpression | 1679 | * BracedAggregateExpression returns UnaryExpression |
1604 | * AtomicExpression returns UnaryExpression | 1680 | * AtomicExpression returns UnaryExpression |
1605 | * | 1681 | * |
1606 | * Constraint: | 1682 | * Constraint: |
1607 | * (op=UnaryOp body=AggregationExpression) | 1683 | * (op=UnaryOperator body=BracedAggregateExpression) |
1608 | */ | 1684 | */ |
1609 | protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) { | 1685 | protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) { |
1610 | if (errorAcceptor != null) { | 1686 | if (errorAcceptor != null) { |
@@ -1614,43 +1690,66 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
1614 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY)); | 1690 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY)); |
1615 | } | 1691 | } |
1616 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1692 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1617 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0(), semanticObject.getOp()); | 1693 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0(), semanticObject.getOp()); |
1618 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0(), semanticObject.getBody()); | 1694 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0(), semanticObject.getBody()); |
1619 | feeder.finish(); | 1695 | feeder.finish(); |
1620 | } | 1696 | } |
1621 | 1697 | ||
1622 | 1698 | ||
1623 | /** | 1699 | /** |
1624 | * Contexts: | 1700 | * Contexts: |
1625 | * Statement returns UnnamedErrorPrediateDefinition | 1701 | * Multiplicity returns UnboundedMultiplicity |
1626 | * UnnamedErrorPrediateDefinition returns UnnamedErrorPrediateDefinition | 1702 | * UnboundedMultiplicity returns UnboundedMultiplicity |
1703 | * | ||
1704 | * Constraint: | ||
1705 | * {UnboundedMultiplicity} | ||
1706 | */ | ||
1707 | protected void sequence_UnboundedMultiplicity(ISerializationContext context, UnboundedMultiplicity semanticObject) { | ||
1708 | genericSequencer.createSequence(context, semanticObject); | ||
1709 | } | ||
1710 | |||
1711 | |||
1712 | /** | ||
1713 | * Contexts: | ||
1714 | * Statement returns UnnamedErrorPredicateDefintion | ||
1715 | * UnnamedErrorPredicateDefintion returns UnnamedErrorPredicateDefintion | ||
1627 | * | 1716 | * |
1628 | * Constraint: | 1717 | * Constraint: |
1629 | * (argumentList=ArgumentList body=Expression) | 1718 | * (argumentList=ArgumentList body=Expression) |
1630 | */ | 1719 | */ |
1631 | protected void sequence_UnnamedErrorPrediateDefinition(ISerializationContext context, UnnamedErrorPrediateDefinition semanticObject) { | 1720 | protected void sequence_UnnamedErrorPredicateDefintion(ISerializationContext context, UnnamedErrorPredicateDefintion semanticObject) { |
1632 | if (errorAcceptor != null) { | 1721 | if (errorAcceptor != null) { |
1633 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES) | 1722 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__ARGUMENT_LIST) == ValueTransient.YES) |
1634 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST)); | 1723 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__ARGUMENT_LIST)); |
1635 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY) == ValueTransient.YES) | 1724 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__BODY) == ValueTransient.YES) |
1636 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY)); | 1725 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__BODY)); |
1637 | } | 1726 | } |
1638 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1727 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
1639 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); | 1728 | feeder.accept(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); |
1640 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | 1729 | feeder.accept(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); |
1641 | feeder.finish(); | 1730 | feeder.finish(); |
1642 | } | 1731 | } |
1643 | 1732 | ||
1644 | 1733 | ||
1645 | /** | 1734 | /** |
1646 | * Contexts: | 1735 | * Contexts: |
1647 | * Variable returns Variable | 1736 | * Import returns UriImport |
1737 | * UriImport returns UriImport | ||
1648 | * | 1738 | * |
1649 | * Constraint: | 1739 | * Constraint: |
1650 | * (type=[NamedElement|QualifiedName]? name=ID) | 1740 | * (uri=STRING alias=QualifiedName) |
1651 | */ | 1741 | */ |
1652 | protected void sequence_Variable(ISerializationContext context, Variable semanticObject) { | 1742 | protected void sequence_UriImport(ISerializationContext context, UriImport semanticObject) { |
1653 | genericSequencer.createSequence(context, semanticObject); | 1743 | if (errorAcceptor != null) { |
1744 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.URI_IMPORT__URI) == ValueTransient.YES) | ||
1745 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.URI_IMPORT__URI)); | ||
1746 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS) == ValueTransient.YES) | ||
1747 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS)); | ||
1748 | } | ||
1749 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1750 | feeder.accept(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0(), semanticObject.getUri()); | ||
1751 | feeder.accept(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0(), semanticObject.getAlias()); | ||
1752 | feeder.finish(); | ||
1654 | } | 1753 | } |
1655 | 1754 | ||
1656 | 1755 | ||