diff options
Diffstat (limited to 'Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/serializer/SmtLanguageSemanticSequencer.java')
-rw-r--r-- | Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/serializer/SmtLanguageSemanticSequencer.java | 1482 |
1 files changed, 1482 insertions, 0 deletions
diff --git a/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/serializer/SmtLanguageSemanticSequencer.java b/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/serializer/SmtLanguageSemanticSequencer.java new file mode 100644 index 00000000..b74e1653 --- /dev/null +++ b/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/src-gen/hu/bme/mit/inf/dslreasoner/serializer/SmtLanguageSemanticSequencer.java | |||
@@ -0,0 +1,1482 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.serializer; | ||
2 | |||
3 | import com.google.inject.Inject; | ||
4 | import com.google.inject.Provider; | ||
5 | import hu.bme.mit.inf.dslreasoner.services.SmtLanguageGrammarAccess; | ||
6 | import hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningProbe; | ||
7 | import hu.bme.mit.inf.dslreasoner.smtLanguage.ReasoningTacticParameter; | ||
8 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAnd; | ||
9 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAndThenCombinator; | ||
10 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTAssertion; | ||
11 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolLiteral; | ||
12 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBoolTypeReference; | ||
13 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTBuiltinTactic; | ||
14 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTCardinalityConstraint; | ||
15 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexSatCommand; | ||
16 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTComplexTypeReference; | ||
17 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDistinct; | ||
18 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDiv; | ||
19 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDivison; | ||
20 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTDocument; | ||
21 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumLiteral; | ||
22 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEnumeratedTypeDeclaration; | ||
23 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTEquals; | ||
24 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTErrorResult; | ||
25 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTExists; | ||
26 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFailIfCombinator; | ||
27 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTForall; | ||
28 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDeclaration; | ||
29 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTFunctionDefinition; | ||
30 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTGetModelCommand; | ||
31 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTITE; | ||
32 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIfCombinator; | ||
33 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIff; | ||
34 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTImpl; | ||
35 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInlineConstantDefinition; | ||
36 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTInput; | ||
37 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntLiteral; | ||
38 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTIntTypeReference; | ||
39 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLEQ; | ||
40 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLT; | ||
41 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTLet; | ||
42 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMEQ; | ||
43 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMT; | ||
44 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMinus; | ||
45 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMod; | ||
46 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTModelResult; | ||
47 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTMultiply; | ||
48 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTNot; | ||
49 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOption; | ||
50 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOr; | ||
51 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOrElseCombinator; | ||
52 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTOutput; | ||
53 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParOrCombinator; | ||
54 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTParThenCombinator; | ||
55 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTPlus; | ||
56 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealLiteral; | ||
57 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTRealTypeReference; | ||
58 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSatResult; | ||
59 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSetTypeDeclaration; | ||
60 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSimpleSatCommand; | ||
61 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSortedVariable; | ||
62 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticDoubleValue; | ||
63 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticIntValue; | ||
64 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTStatisticsSection; | ||
65 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTSymbolicValue; | ||
66 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTTryForCombinator; | ||
67 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUnsupportedResult; | ||
68 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTUsingParamCombinator; | ||
69 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SMTWhenCombinator; | ||
70 | import hu.bme.mit.inf.dslreasoner.smtLanguage.SmtLanguagePackage; | ||
71 | import org.eclipse.emf.ecore.EObject; | ||
72 | import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor; | ||
73 | import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; | ||
74 | import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider; | ||
75 | import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor; | ||
76 | import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; | ||
77 | import org.eclipse.xtext.serializer.sequencer.GenericSequencer; | ||
78 | import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider; | ||
79 | import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; | ||
80 | import org.eclipse.xtext.serializer.sequencer.ITransientValueService; | ||
81 | import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; | ||
82 | |||
83 | @SuppressWarnings("all") | ||
84 | public class SmtLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer { | ||
85 | |||
86 | @Inject | ||
87 | private SmtLanguageGrammarAccess grammarAccess; | ||
88 | |||
89 | public void createSequence(EObject context, EObject semanticObject) { | ||
90 | if(semanticObject.eClass().getEPackage() == SmtLanguagePackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) { | ||
91 | case SmtLanguagePackage.REASONING_PROBE: | ||
92 | if(context == grammarAccess.getReasoningProbeRule()) { | ||
93 | sequence_ReasoningProbe(context, (ReasoningProbe) semanticObject); | ||
94 | return; | ||
95 | } | ||
96 | else break; | ||
97 | case SmtLanguagePackage.REASONING_TACTIC_PARAMETER: | ||
98 | if(context == grammarAccess.getReasoningTacticParameterRule()) { | ||
99 | sequence_ReasoningTacticParameter(context, (ReasoningTacticParameter) semanticObject); | ||
100 | return; | ||
101 | } | ||
102 | else break; | ||
103 | case SmtLanguagePackage.SMT_AND: | ||
104 | if(context == grammarAccess.getSMTAndRule() || | ||
105 | context == grammarAccess.getSMTBoolOperationRule() || | ||
106 | context == grammarAccess.getSMTTermRule()) { | ||
107 | sequence_SMTAnd(context, (SMTAnd) semanticObject); | ||
108 | return; | ||
109 | } | ||
110 | else break; | ||
111 | case SmtLanguagePackage.SMT_AND_THEN_COMBINATOR: | ||
112 | if(context == grammarAccess.getSMTAndThenCombinatorRule() || | ||
113 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
114 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
115 | sequence_SMTAndThenCombinator(context, (SMTAndThenCombinator) semanticObject); | ||
116 | return; | ||
117 | } | ||
118 | else break; | ||
119 | case SmtLanguagePackage.SMT_ASSERTION: | ||
120 | if(context == grammarAccess.getSMTAssertionRule()) { | ||
121 | sequence_SMTAssertion(context, (SMTAssertion) semanticObject); | ||
122 | return; | ||
123 | } | ||
124 | else break; | ||
125 | case SmtLanguagePackage.SMT_BOOL_LITERAL: | ||
126 | if(context == grammarAccess.getSMTAtomicTermRule() || | ||
127 | context == grammarAccess.getSMTBoolLiteralRule() || | ||
128 | context == grammarAccess.getSMTTermRule()) { | ||
129 | sequence_SMTBoolLiteral(context, (SMTBoolLiteral) semanticObject); | ||
130 | return; | ||
131 | } | ||
132 | else break; | ||
133 | case SmtLanguagePackage.SMT_BOOL_TYPE_REFERENCE: | ||
134 | if(context == grammarAccess.getSMTBoolTypeReferenceRule() || | ||
135 | context == grammarAccess.getSMTPrimitiveTypeReferenceRule() || | ||
136 | context == grammarAccess.getSMTTypeReferenceRule()) { | ||
137 | sequence_SMTBoolTypeReference(context, (SMTBoolTypeReference) semanticObject); | ||
138 | return; | ||
139 | } | ||
140 | else break; | ||
141 | case SmtLanguagePackage.SMT_BUILTIN_TACTIC: | ||
142 | if(context == grammarAccess.getSMTBuiltinTacticRule() || | ||
143 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
144 | sequence_SMTBuiltinTactic(context, (SMTBuiltinTactic) semanticObject); | ||
145 | return; | ||
146 | } | ||
147 | else break; | ||
148 | case SmtLanguagePackage.SMT_CARDINALITY_CONSTRAINT: | ||
149 | if(context == grammarAccess.getSMTCardinalityConstraintRule()) { | ||
150 | sequence_SMTCardinalityConstraint(context, (SMTCardinalityConstraint) semanticObject); | ||
151 | return; | ||
152 | } | ||
153 | else break; | ||
154 | case SmtLanguagePackage.SMT_COMPLEX_SAT_COMMAND: | ||
155 | if(context == grammarAccess.getSMTComplexSatCommandRule() || | ||
156 | context == grammarAccess.getSMTSatCommandRule()) { | ||
157 | sequence_SMTComplexSatCommand(context, (SMTComplexSatCommand) semanticObject); | ||
158 | return; | ||
159 | } | ||
160 | else break; | ||
161 | case SmtLanguagePackage.SMT_COMPLEX_TYPE_REFERENCE: | ||
162 | if(context == grammarAccess.getSMTComplexTypeReferenceRule() || | ||
163 | context == grammarAccess.getSMTTypeReferenceRule()) { | ||
164 | sequence_SMTComplexTypeReference(context, (SMTComplexTypeReference) semanticObject); | ||
165 | return; | ||
166 | } | ||
167 | else break; | ||
168 | case SmtLanguagePackage.SMT_DISTINCT: | ||
169 | if(context == grammarAccess.getSMTDistinctRule() || | ||
170 | context == grammarAccess.getSMTRelationRule() || | ||
171 | context == grammarAccess.getSMTTermRule()) { | ||
172 | sequence_SMTDistinct(context, (SMTDistinct) semanticObject); | ||
173 | return; | ||
174 | } | ||
175 | else break; | ||
176 | case SmtLanguagePackage.SMT_DIV: | ||
177 | if(context == grammarAccess.getSMTDivRule() || | ||
178 | context == grammarAccess.getSMTIntOperationRule() || | ||
179 | context == grammarAccess.getSMTTermRule()) { | ||
180 | sequence_SMTDiv(context, (SMTDiv) semanticObject); | ||
181 | return; | ||
182 | } | ||
183 | else break; | ||
184 | case SmtLanguagePackage.SMT_DIVISON: | ||
185 | if(context == grammarAccess.getSMTDivisonRule() || | ||
186 | context == grammarAccess.getSMTIntOperationRule() || | ||
187 | context == grammarAccess.getSMTTermRule()) { | ||
188 | sequence_SMTDivison(context, (SMTDivison) semanticObject); | ||
189 | return; | ||
190 | } | ||
191 | else break; | ||
192 | case SmtLanguagePackage.SMT_DOCUMENT: | ||
193 | if(context == grammarAccess.getSMTDocumentRule()) { | ||
194 | sequence_SMTDocument(context, (SMTDocument) semanticObject); | ||
195 | return; | ||
196 | } | ||
197 | else break; | ||
198 | case SmtLanguagePackage.SMT_ENUM_LITERAL: | ||
199 | if(context == grammarAccess.getSMTEnumLiteralRule() || | ||
200 | context == grammarAccess.getSMTSymbolicDeclarationRule()) { | ||
201 | sequence_SMTEnumLiteral(context, (SMTEnumLiteral) semanticObject); | ||
202 | return; | ||
203 | } | ||
204 | else break; | ||
205 | case SmtLanguagePackage.SMT_ENUMERATED_TYPE_DECLARATION: | ||
206 | if(context == grammarAccess.getSMTEnumeratedTypeDeclarationRule() || | ||
207 | context == grammarAccess.getSMTTypeRule()) { | ||
208 | sequence_SMTEnumeratedTypeDeclaration(context, (SMTEnumeratedTypeDeclaration) semanticObject); | ||
209 | return; | ||
210 | } | ||
211 | else break; | ||
212 | case SmtLanguagePackage.SMT_EQUALS: | ||
213 | if(context == grammarAccess.getSMTEqualsRule() || | ||
214 | context == grammarAccess.getSMTRelationRule() || | ||
215 | context == grammarAccess.getSMTTermRule()) { | ||
216 | sequence_SMTEquals(context, (SMTEquals) semanticObject); | ||
217 | return; | ||
218 | } | ||
219 | else break; | ||
220 | case SmtLanguagePackage.SMT_ERROR_RESULT: | ||
221 | if(context == grammarAccess.getSMTErrorResultRule() || | ||
222 | context == grammarAccess.getSMTResultRule()) { | ||
223 | sequence_SMTErrorResult(context, (SMTErrorResult) semanticObject); | ||
224 | return; | ||
225 | } | ||
226 | else break; | ||
227 | case SmtLanguagePackage.SMT_EXISTS: | ||
228 | if(context == grammarAccess.getSMTExistsRule() || | ||
229 | context == grammarAccess.getSMTQuantifiedExpressionRule() || | ||
230 | context == grammarAccess.getSMTTermRule()) { | ||
231 | sequence_SMTExists(context, (SMTExists) semanticObject); | ||
232 | return; | ||
233 | } | ||
234 | else break; | ||
235 | case SmtLanguagePackage.SMT_FAIL_IF_COMBINATOR: | ||
236 | if(context == grammarAccess.getSMTFailIfCombinatorRule() || | ||
237 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
238 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
239 | sequence_SMTFailIfCombinator(context, (SMTFailIfCombinator) semanticObject); | ||
240 | return; | ||
241 | } | ||
242 | else break; | ||
243 | case SmtLanguagePackage.SMT_FORALL: | ||
244 | if(context == grammarAccess.getSMTForallRule() || | ||
245 | context == grammarAccess.getSMTQuantifiedExpressionRule() || | ||
246 | context == grammarAccess.getSMTTermRule()) { | ||
247 | sequence_SMTForall(context, (SMTForall) semanticObject); | ||
248 | return; | ||
249 | } | ||
250 | else break; | ||
251 | case SmtLanguagePackage.SMT_FUNCTION_DECLARATION: | ||
252 | if(context == grammarAccess.getSMTFunctionDeclarationRule() || | ||
253 | context == grammarAccess.getSMTSymbolicDeclarationRule()) { | ||
254 | sequence_SMTFunctionDeclaration(context, (SMTFunctionDeclaration) semanticObject); | ||
255 | return; | ||
256 | } | ||
257 | else break; | ||
258 | case SmtLanguagePackage.SMT_FUNCTION_DEFINITION: | ||
259 | if(context == grammarAccess.getSMTFunctionDefinitionRule() || | ||
260 | context == grammarAccess.getSMTSymbolicDeclarationRule()) { | ||
261 | sequence_SMTFunctionDefinition(context, (SMTFunctionDefinition) semanticObject); | ||
262 | return; | ||
263 | } | ||
264 | else break; | ||
265 | case SmtLanguagePackage.SMT_GET_MODEL_COMMAND: | ||
266 | if(context == grammarAccess.getSMTGetModelCommandRule()) { | ||
267 | sequence_SMTGetModelCommand(context, (SMTGetModelCommand) semanticObject); | ||
268 | return; | ||
269 | } | ||
270 | else break; | ||
271 | case SmtLanguagePackage.SMTITE: | ||
272 | if(context == grammarAccess.getSMTITERule() || | ||
273 | context == grammarAccess.getSMTTermRule()) { | ||
274 | sequence_SMTITE(context, (SMTITE) semanticObject); | ||
275 | return; | ||
276 | } | ||
277 | else break; | ||
278 | case SmtLanguagePackage.SMT_IF_COMBINATOR: | ||
279 | if(context == grammarAccess.getSMTIfCombinatorRule() || | ||
280 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
281 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
282 | sequence_SMTIfCombinator(context, (SMTIfCombinator) semanticObject); | ||
283 | return; | ||
284 | } | ||
285 | else break; | ||
286 | case SmtLanguagePackage.SMT_IFF: | ||
287 | if(context == grammarAccess.getSMTBoolOperationRule() || | ||
288 | context == grammarAccess.getSMTIffRule() || | ||
289 | context == grammarAccess.getSMTTermRule()) { | ||
290 | sequence_SMTIff(context, (SMTIff) semanticObject); | ||
291 | return; | ||
292 | } | ||
293 | else break; | ||
294 | case SmtLanguagePackage.SMT_IMPL: | ||
295 | if(context == grammarAccess.getSMTBoolOperationRule() || | ||
296 | context == grammarAccess.getSMTImplRule() || | ||
297 | context == grammarAccess.getSMTTermRule()) { | ||
298 | sequence_SMTImpl(context, (SMTImpl) semanticObject); | ||
299 | return; | ||
300 | } | ||
301 | else break; | ||
302 | case SmtLanguagePackage.SMT_INLINE_CONSTANT_DEFINITION: | ||
303 | if(context == grammarAccess.getSMTInlineConstantDefinitionRule() || | ||
304 | context == grammarAccess.getSMTSymbolicDeclarationRule()) { | ||
305 | sequence_SMTInlineConstantDefinition(context, (SMTInlineConstantDefinition) semanticObject); | ||
306 | return; | ||
307 | } | ||
308 | else break; | ||
309 | case SmtLanguagePackage.SMT_INPUT: | ||
310 | if(context == grammarAccess.getSMTInputRule()) { | ||
311 | sequence_SMTInput(context, (SMTInput) semanticObject); | ||
312 | return; | ||
313 | } | ||
314 | else break; | ||
315 | case SmtLanguagePackage.SMT_INT_LITERAL: | ||
316 | if(context == grammarAccess.getSMTAtomicTermRule() || | ||
317 | context == grammarAccess.getSMTIntLiteralRule() || | ||
318 | context == grammarAccess.getSMTTermRule()) { | ||
319 | sequence_SMTIntLiteral(context, (SMTIntLiteral) semanticObject); | ||
320 | return; | ||
321 | } | ||
322 | else break; | ||
323 | case SmtLanguagePackage.SMT_INT_TYPE_REFERENCE: | ||
324 | if(context == grammarAccess.getSMTIntTypeReferenceRule() || | ||
325 | context == grammarAccess.getSMTPrimitiveTypeReferenceRule() || | ||
326 | context == grammarAccess.getSMTTypeReferenceRule()) { | ||
327 | sequence_SMTIntTypeReference(context, (SMTIntTypeReference) semanticObject); | ||
328 | return; | ||
329 | } | ||
330 | else break; | ||
331 | case SmtLanguagePackage.SMTLEQ: | ||
332 | if(context == grammarAccess.getSMTLEQRule() || | ||
333 | context == grammarAccess.getSMTRelationRule() || | ||
334 | context == grammarAccess.getSMTTermRule()) { | ||
335 | sequence_SMTLEQ(context, (SMTLEQ) semanticObject); | ||
336 | return; | ||
337 | } | ||
338 | else break; | ||
339 | case SmtLanguagePackage.SMTLT: | ||
340 | if(context == grammarAccess.getSMTLTRule() || | ||
341 | context == grammarAccess.getSMTRelationRule() || | ||
342 | context == grammarAccess.getSMTTermRule()) { | ||
343 | sequence_SMTLT(context, (SMTLT) semanticObject); | ||
344 | return; | ||
345 | } | ||
346 | else break; | ||
347 | case SmtLanguagePackage.SMT_LET: | ||
348 | if(context == grammarAccess.getSMTLetRule() || | ||
349 | context == grammarAccess.getSMTTermRule()) { | ||
350 | sequence_SMTLet(context, (SMTLet) semanticObject); | ||
351 | return; | ||
352 | } | ||
353 | else break; | ||
354 | case SmtLanguagePackage.SMTMEQ: | ||
355 | if(context == grammarAccess.getSMTMEQRule() || | ||
356 | context == grammarAccess.getSMTRelationRule() || | ||
357 | context == grammarAccess.getSMTTermRule()) { | ||
358 | sequence_SMTMEQ(context, (SMTMEQ) semanticObject); | ||
359 | return; | ||
360 | } | ||
361 | else break; | ||
362 | case SmtLanguagePackage.SMTMT: | ||
363 | if(context == grammarAccess.getSMTMTRule() || | ||
364 | context == grammarAccess.getSMTRelationRule() || | ||
365 | context == grammarAccess.getSMTTermRule()) { | ||
366 | sequence_SMTMT(context, (SMTMT) semanticObject); | ||
367 | return; | ||
368 | } | ||
369 | else break; | ||
370 | case SmtLanguagePackage.SMT_MINUS: | ||
371 | if(context == grammarAccess.getSMTIntOperationRule() || | ||
372 | context == grammarAccess.getSMTMinusRule() || | ||
373 | context == grammarAccess.getSMTTermRule()) { | ||
374 | sequence_SMTMinus(context, (SMTMinus) semanticObject); | ||
375 | return; | ||
376 | } | ||
377 | else break; | ||
378 | case SmtLanguagePackage.SMT_MOD: | ||
379 | if(context == grammarAccess.getSMTIntOperationRule() || | ||
380 | context == grammarAccess.getSMTModRule() || | ||
381 | context == grammarAccess.getSMTTermRule()) { | ||
382 | sequence_SMTMod(context, (SMTMod) semanticObject); | ||
383 | return; | ||
384 | } | ||
385 | else break; | ||
386 | case SmtLanguagePackage.SMT_MODEL_RESULT: | ||
387 | if(context == grammarAccess.getSMTModelResultRule() || | ||
388 | context == grammarAccess.getSMTResultRule()) { | ||
389 | sequence_SMTModelResult(context, (SMTModelResult) semanticObject); | ||
390 | return; | ||
391 | } | ||
392 | else break; | ||
393 | case SmtLanguagePackage.SMT_MULTIPLY: | ||
394 | if(context == grammarAccess.getSMTIntOperationRule() || | ||
395 | context == grammarAccess.getSMTMultiplyRule() || | ||
396 | context == grammarAccess.getSMTTermRule()) { | ||
397 | sequence_SMTMultiply(context, (SMTMultiply) semanticObject); | ||
398 | return; | ||
399 | } | ||
400 | else break; | ||
401 | case SmtLanguagePackage.SMT_NOT: | ||
402 | if(context == grammarAccess.getSMTBoolOperationRule() || | ||
403 | context == grammarAccess.getSMTNotRule() || | ||
404 | context == grammarAccess.getSMTTermRule()) { | ||
405 | sequence_SMTNot(context, (SMTNot) semanticObject); | ||
406 | return; | ||
407 | } | ||
408 | else break; | ||
409 | case SmtLanguagePackage.SMT_OPTION: | ||
410 | if(context == grammarAccess.getSMTOptionRule()) { | ||
411 | sequence_SMTOption(context, (SMTOption) semanticObject); | ||
412 | return; | ||
413 | } | ||
414 | else break; | ||
415 | case SmtLanguagePackage.SMT_OR: | ||
416 | if(context == grammarAccess.getSMTBoolOperationRule() || | ||
417 | context == grammarAccess.getSMTOrRule() || | ||
418 | context == grammarAccess.getSMTTermRule()) { | ||
419 | sequence_SMTOr(context, (SMTOr) semanticObject); | ||
420 | return; | ||
421 | } | ||
422 | else break; | ||
423 | case SmtLanguagePackage.SMT_OR_ELSE_COMBINATOR: | ||
424 | if(context == grammarAccess.getSMTOrElseCombinatorRule() || | ||
425 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
426 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
427 | sequence_SMTOrElseCombinator(context, (SMTOrElseCombinator) semanticObject); | ||
428 | return; | ||
429 | } | ||
430 | else break; | ||
431 | case SmtLanguagePackage.SMT_OUTPUT: | ||
432 | if(context == grammarAccess.getSMTOutputRule()) { | ||
433 | sequence_SMTOutput(context, (SMTOutput) semanticObject); | ||
434 | return; | ||
435 | } | ||
436 | else break; | ||
437 | case SmtLanguagePackage.SMT_PAR_OR_COMBINATOR: | ||
438 | if(context == grammarAccess.getSMTParOrCombinatorRule() || | ||
439 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
440 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
441 | sequence_SMTParOrCombinator(context, (SMTParOrCombinator) semanticObject); | ||
442 | return; | ||
443 | } | ||
444 | else break; | ||
445 | case SmtLanguagePackage.SMT_PAR_THEN_COMBINATOR: | ||
446 | if(context == grammarAccess.getSMTParThenCombinatorRule() || | ||
447 | context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
448 | context == grammarAccess.getSMTReasoningTacticRule()) { | ||
449 | sequence_SMTParThenCombinator(context, (SMTParThenCombinator) semanticObject); | ||
450 | return; | ||
451 | } | ||
452 | else break; | ||
453 | case SmtLanguagePackage.SMT_PLUS: | ||
454 | if(context == grammarAccess.getSMTIntOperationRule() || | ||
455 | context == grammarAccess.getSMTPlusRule() || | ||
456 | context == grammarAccess.getSMTTermRule()) { | ||
457 | sequence_SMTPlus(context, (SMTPlus) semanticObject); | ||
458 | return; | ||
459 | } | ||
460 | else break; | ||
461 | case SmtLanguagePackage.SMT_REAL_LITERAL: | ||
462 | if(context == grammarAccess.getSMTAtomicTermRule() || | ||
463 | context == grammarAccess.getSMTRealLiteralRule() || | ||
464 | context == grammarAccess.getSMTTermRule()) { | ||
465 | sequence_SMTRealLiteral(context, (SMTRealLiteral) semanticObject); | ||
466 | return; | ||
467 | } | ||
468 | else break; | ||
469 | case SmtLanguagePackage.SMT_REAL_TYPE_REFERENCE: | ||
470 | if(context == grammarAccess.getSMTPrimitiveTypeReferenceRule() || | ||
471 | context == grammarAccess.getSMTRealTypeReferenceRule() || | ||
472 | context == grammarAccess.getSMTTypeReferenceRule()) { | ||
473 | sequence_SMTRealTypeReference(context, (SMTRealTypeReference) semanticObject); | ||
474 | return; | ||
475 | } | ||
476 | else break; | ||
477 | case SmtLanguagePackage.SMT_SAT_RESULT: | ||
478 | if(context == grammarAccess.getSMTResultRule() || | ||
479 | context == grammarAccess.getSMTSatResultRule()) { | ||
480 | sequence_SMTSatResult(context, (SMTSatResult) semanticObject); | ||
481 | return; | ||
482 | } | ||
483 | else break; | ||
484 | case SmtLanguagePackage.SMT_SET_TYPE_DECLARATION: | ||
485 | if(context == grammarAccess.getSMTSetTypeDeclarationRule() || | ||
486 | context == grammarAccess.getSMTTypeRule()) { | ||
487 | sequence_SMTSetTypeDeclaration(context, (SMTSetTypeDeclaration) semanticObject); | ||
488 | return; | ||
489 | } | ||
490 | else break; | ||
491 | case SmtLanguagePackage.SMT_SIMPLE_SAT_COMMAND: | ||
492 | if(context == grammarAccess.getSMTSatCommandRule() || | ||
493 | context == grammarAccess.getSMTSimpleSatCommandRule()) { | ||
494 | sequence_SMTSimpleSatCommand(context, (SMTSimpleSatCommand) semanticObject); | ||
495 | return; | ||
496 | } | ||
497 | else break; | ||
498 | case SmtLanguagePackage.SMT_SORTED_VARIABLE: | ||
499 | if(context == grammarAccess.getSMTSortedVariableRule() || | ||
500 | context == grammarAccess.getSMTSymbolicDeclarationRule()) { | ||
501 | sequence_SMTSortedVariable(context, (SMTSortedVariable) semanticObject); | ||
502 | return; | ||
503 | } | ||
504 | else break; | ||
505 | case SmtLanguagePackage.SMT_STATISTIC_DOUBLE_VALUE: | ||
506 | if(context == grammarAccess.getSMTStatisticDoubleValueRule() || | ||
507 | context == grammarAccess.getSMTStatisticValueRule()) { | ||
508 | sequence_SMTStatisticDoubleValue(context, (SMTStatisticDoubleValue) semanticObject); | ||
509 | return; | ||
510 | } | ||
511 | else break; | ||
512 | case SmtLanguagePackage.SMT_STATISTIC_INT_VALUE: | ||
513 | if(context == grammarAccess.getSMTStatisticIntValueRule() || | ||
514 | context == grammarAccess.getSMTStatisticValueRule()) { | ||
515 | sequence_SMTStatisticIntValue(context, (SMTStatisticIntValue) semanticObject); | ||
516 | return; | ||
517 | } | ||
518 | else break; | ||
519 | case SmtLanguagePackage.SMT_STATISTICS_SECTION: | ||
520 | if(context == grammarAccess.getSMTStatisticsSectionRule()) { | ||
521 | sequence_SMTStatisticsSection(context, (SMTStatisticsSection) semanticObject); | ||
522 | return; | ||
523 | } | ||
524 | else break; | ||
525 | case SmtLanguagePackage.SMT_SYMBOLIC_VALUE: | ||
526 | if(context == grammarAccess.getSMTSymbolicValueRule() || | ||
527 | context == grammarAccess.getSMTTermRule()) { | ||
528 | sequence_SMTSymbolicValue(context, (SMTSymbolicValue) semanticObject); | ||
529 | return; | ||
530 | } | ||
531 | else break; | ||
532 | case SmtLanguagePackage.SMT_TRY_FOR_COMBINATOR: | ||
533 | if(context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
534 | context == grammarAccess.getSMTReasoningTacticRule() || | ||
535 | context == grammarAccess.getSMTTryForCombinatorRule()) { | ||
536 | sequence_SMTTryForCombinator(context, (SMTTryForCombinator) semanticObject); | ||
537 | return; | ||
538 | } | ||
539 | else break; | ||
540 | case SmtLanguagePackage.SMT_UNSUPPORTED_RESULT: | ||
541 | if(context == grammarAccess.getSMTResultRule() || | ||
542 | context == grammarAccess.getSMTUnsupportedResultRule()) { | ||
543 | sequence_SMTUnsupportedResult(context, (SMTUnsupportedResult) semanticObject); | ||
544 | return; | ||
545 | } | ||
546 | else break; | ||
547 | case SmtLanguagePackage.SMT_USING_PARAM_COMBINATOR: | ||
548 | if(context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
549 | context == grammarAccess.getSMTReasoningTacticRule() || | ||
550 | context == grammarAccess.getSMTUsingParamCombinatorRule()) { | ||
551 | sequence_SMTUsingParamCombinator(context, (SMTUsingParamCombinator) semanticObject); | ||
552 | return; | ||
553 | } | ||
554 | else break; | ||
555 | case SmtLanguagePackage.SMT_WHEN_COMBINATOR: | ||
556 | if(context == grammarAccess.getSMTReasoningCombinatorRule() || | ||
557 | context == grammarAccess.getSMTReasoningTacticRule() || | ||
558 | context == grammarAccess.getSMTWhenCombinatorRule()) { | ||
559 | sequence_SMTWhenCombinator(context, (SMTWhenCombinator) semanticObject); | ||
560 | return; | ||
561 | } | ||
562 | else break; | ||
563 | } | ||
564 | if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); | ||
565 | } | ||
566 | |||
567 | /** | ||
568 | * Constraint: | ||
569 | * name=ID | ||
570 | */ | ||
571 | protected void sequence_ReasoningProbe(EObject context, ReasoningProbe semanticObject) { | ||
572 | if(errorAcceptor != null) { | ||
573 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.REASONING_PROBE__NAME) == ValueTransient.YES) | ||
574 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.REASONING_PROBE__NAME)); | ||
575 | } | ||
576 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
577 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
578 | feeder.accept(grammarAccess.getReasoningProbeAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | ||
579 | feeder.finish(); | ||
580 | } | ||
581 | |||
582 | |||
583 | /** | ||
584 | * Constraint: | ||
585 | * (name=PROPERTYNAME value=SMTAtomicTerm) | ||
586 | */ | ||
587 | protected void sequence_ReasoningTacticParameter(EObject context, ReasoningTacticParameter semanticObject) { | ||
588 | if(errorAcceptor != null) { | ||
589 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.REASONING_TACTIC_PARAMETER__NAME) == ValueTransient.YES) | ||
590 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.REASONING_TACTIC_PARAMETER__NAME)); | ||
591 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.REASONING_TACTIC_PARAMETER__VALUE) == ValueTransient.YES) | ||
592 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.REASONING_TACTIC_PARAMETER__VALUE)); | ||
593 | } | ||
594 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
595 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
596 | feeder.accept(grammarAccess.getReasoningTacticParameterAccess().getNamePROPERTYNAMETerminalRuleCall_0_0(), semanticObject.getName()); | ||
597 | feeder.accept(grammarAccess.getReasoningTacticParameterAccess().getValueSMTAtomicTermParserRuleCall_1_0(), semanticObject.getValue()); | ||
598 | feeder.finish(); | ||
599 | } | ||
600 | |||
601 | |||
602 | /** | ||
603 | * Constraint: | ||
604 | * tactics+=SMTReasoningTactic+ | ||
605 | */ | ||
606 | protected void sequence_SMTAndThenCombinator(EObject context, SMTAndThenCombinator semanticObject) { | ||
607 | genericSequencer.createSequence(context, semanticObject); | ||
608 | } | ||
609 | |||
610 | |||
611 | /** | ||
612 | * Constraint: | ||
613 | * operands+=SMTTerm+ | ||
614 | */ | ||
615 | protected void sequence_SMTAnd(EObject context, SMTAnd semanticObject) { | ||
616 | genericSequencer.createSequence(context, semanticObject); | ||
617 | } | ||
618 | |||
619 | |||
620 | /** | ||
621 | * Constraint: | ||
622 | * value=SMTTerm | ||
623 | */ | ||
624 | protected void sequence_SMTAssertion(EObject context, SMTAssertion semanticObject) { | ||
625 | if(errorAcceptor != null) { | ||
626 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_ASSERTION__VALUE) == ValueTransient.YES) | ||
627 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_ASSERTION__VALUE)); | ||
628 | } | ||
629 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
630 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
631 | feeder.accept(grammarAccess.getSMTAssertionAccess().getValueSMTTermParserRuleCall_2_0(), semanticObject.getValue()); | ||
632 | feeder.finish(); | ||
633 | } | ||
634 | |||
635 | |||
636 | /** | ||
637 | * Constraint: | ||
638 | * value=BOOLEANTERMINAL | ||
639 | */ | ||
640 | protected void sequence_SMTBoolLiteral(EObject context, SMTBoolLiteral semanticObject) { | ||
641 | if(errorAcceptor != null) { | ||
642 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_BOOL_LITERAL__VALUE) == ValueTransient.YES) | ||
643 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_BOOL_LITERAL__VALUE)); | ||
644 | } | ||
645 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
646 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
647 | feeder.accept(grammarAccess.getSMTBoolLiteralAccess().getValueBOOLEANTERMINALParserRuleCall_0(), semanticObject.isValue()); | ||
648 | feeder.finish(); | ||
649 | } | ||
650 | |||
651 | |||
652 | /** | ||
653 | * Constraint: | ||
654 | * {SMTBoolTypeReference} | ||
655 | */ | ||
656 | protected void sequence_SMTBoolTypeReference(EObject context, SMTBoolTypeReference semanticObject) { | ||
657 | genericSequencer.createSequence(context, semanticObject); | ||
658 | } | ||
659 | |||
660 | |||
661 | /** | ||
662 | * Constraint: | ||
663 | * name=ID | ||
664 | */ | ||
665 | protected void sequence_SMTBuiltinTactic(EObject context, SMTBuiltinTactic semanticObject) { | ||
666 | if(errorAcceptor != null) { | ||
667 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_BUILTIN_TACTIC__NAME) == ValueTransient.YES) | ||
668 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_BUILTIN_TACTIC__NAME)); | ||
669 | } | ||
670 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
671 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
672 | feeder.accept(grammarAccess.getSMTBuiltinTacticAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | ||
673 | feeder.finish(); | ||
674 | } | ||
675 | |||
676 | |||
677 | /** | ||
678 | * Constraint: | ||
679 | * (type=SMTTypeReference (elements+=SMTSymbolicValue* | elements+=SMTSymbolicValue)) | ||
680 | */ | ||
681 | protected void sequence_SMTCardinalityConstraint(EObject context, SMTCardinalityConstraint semanticObject) { | ||
682 | genericSequencer.createSequence(context, semanticObject); | ||
683 | } | ||
684 | |||
685 | |||
686 | /** | ||
687 | * Constraint: | ||
688 | * method=SMTReasoningTactic | ||
689 | */ | ||
690 | protected void sequence_SMTComplexSatCommand(EObject context, SMTComplexSatCommand semanticObject) { | ||
691 | if(errorAcceptor != null) { | ||
692 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_COMPLEX_SAT_COMMAND__METHOD) == ValueTransient.YES) | ||
693 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_COMPLEX_SAT_COMMAND__METHOD)); | ||
694 | } | ||
695 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
696 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
697 | feeder.accept(grammarAccess.getSMTComplexSatCommandAccess().getMethodSMTReasoningTacticParserRuleCall_2_0(), semanticObject.getMethod()); | ||
698 | feeder.finish(); | ||
699 | } | ||
700 | |||
701 | |||
702 | /** | ||
703 | * Constraint: | ||
704 | * referred=[SMTType|ID] | ||
705 | */ | ||
706 | protected void sequence_SMTComplexTypeReference(EObject context, SMTComplexTypeReference semanticObject) { | ||
707 | if(errorAcceptor != null) { | ||
708 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_COMPLEX_TYPE_REFERENCE__REFERRED) == ValueTransient.YES) | ||
709 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_COMPLEX_TYPE_REFERENCE__REFERRED)); | ||
710 | } | ||
711 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
712 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
713 | feeder.accept(grammarAccess.getSMTComplexTypeReferenceAccess().getReferredSMTTypeIDTerminalRuleCall_0_1(), semanticObject.getReferred()); | ||
714 | feeder.finish(); | ||
715 | } | ||
716 | |||
717 | |||
718 | /** | ||
719 | * Constraint: | ||
720 | * operands+=SMTTerm+ | ||
721 | */ | ||
722 | protected void sequence_SMTDistinct(EObject context, SMTDistinct semanticObject) { | ||
723 | genericSequencer.createSequence(context, semanticObject); | ||
724 | } | ||
725 | |||
726 | |||
727 | /** | ||
728 | * Constraint: | ||
729 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
730 | */ | ||
731 | protected void sequence_SMTDiv(EObject context, SMTDiv semanticObject) { | ||
732 | if(errorAcceptor != null) { | ||
733 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND) == ValueTransient.YES) | ||
734 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND)); | ||
735 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND) == ValueTransient.YES) | ||
736 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND)); | ||
737 | } | ||
738 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
739 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
740 | feeder.accept(grammarAccess.getSMTDivAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
741 | feeder.accept(grammarAccess.getSMTDivAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
742 | feeder.finish(); | ||
743 | } | ||
744 | |||
745 | |||
746 | /** | ||
747 | * Constraint: | ||
748 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
749 | */ | ||
750 | protected void sequence_SMTDivison(EObject context, SMTDivison semanticObject) { | ||
751 | if(errorAcceptor != null) { | ||
752 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND) == ValueTransient.YES) | ||
753 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND)); | ||
754 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND) == ValueTransient.YES) | ||
755 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND)); | ||
756 | } | ||
757 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
758 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
759 | feeder.accept(grammarAccess.getSMTDivisonAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
760 | feeder.accept(grammarAccess.getSMTDivisonAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
761 | feeder.finish(); | ||
762 | } | ||
763 | |||
764 | |||
765 | /** | ||
766 | * Constraint: | ||
767 | * (input=SMTInput output=SMTOutput?) | ||
768 | */ | ||
769 | protected void sequence_SMTDocument(EObject context, SMTDocument semanticObject) { | ||
770 | genericSequencer.createSequence(context, semanticObject); | ||
771 | } | ||
772 | |||
773 | |||
774 | /** | ||
775 | * Constraint: | ||
776 | * name=SMTID | ||
777 | */ | ||
778 | protected void sequence_SMTEnumLiteral(EObject context, SMTEnumLiteral semanticObject) { | ||
779 | if(errorAcceptor != null) { | ||
780 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME) == ValueTransient.YES) | ||
781 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME)); | ||
782 | } | ||
783 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
784 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
785 | feeder.accept(grammarAccess.getSMTEnumLiteralAccess().getNameSMTIDParserRuleCall_0(), semanticObject.getName()); | ||
786 | feeder.finish(); | ||
787 | } | ||
788 | |||
789 | |||
790 | /** | ||
791 | * Constraint: | ||
792 | * (name=SMTID elements+=SMTEnumLiteral+) | ||
793 | */ | ||
794 | protected void sequence_SMTEnumeratedTypeDeclaration(EObject context, SMTEnumeratedTypeDeclaration semanticObject) { | ||
795 | genericSequencer.createSequence(context, semanticObject); | ||
796 | } | ||
797 | |||
798 | |||
799 | /** | ||
800 | * Constraint: | ||
801 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
802 | */ | ||
803 | protected void sequence_SMTEquals(EObject context, SMTEquals semanticObject) { | ||
804 | if(errorAcceptor != null) { | ||
805 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_EQUALS__LEFT_OPERAND) == ValueTransient.YES) | ||
806 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_EQUALS__LEFT_OPERAND)); | ||
807 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_EQUALS__RIGHT_OPERAND) == ValueTransient.YES) | ||
808 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_EQUALS__RIGHT_OPERAND)); | ||
809 | } | ||
810 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
811 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
812 | feeder.accept(grammarAccess.getSMTEqualsAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
813 | feeder.accept(grammarAccess.getSMTEqualsAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
814 | feeder.finish(); | ||
815 | } | ||
816 | |||
817 | |||
818 | /** | ||
819 | * Constraint: | ||
820 | * message=STRING | ||
821 | */ | ||
822 | protected void sequence_SMTErrorResult(EObject context, SMTErrorResult semanticObject) { | ||
823 | if(errorAcceptor != null) { | ||
824 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_ERROR_RESULT__MESSAGE) == ValueTransient.YES) | ||
825 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_ERROR_RESULT__MESSAGE)); | ||
826 | } | ||
827 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
828 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
829 | feeder.accept(grammarAccess.getSMTErrorResultAccess().getMessageSTRINGTerminalRuleCall_2_0(), semanticObject.getMessage()); | ||
830 | feeder.finish(); | ||
831 | } | ||
832 | |||
833 | |||
834 | /** | ||
835 | * Constraint: | ||
836 | * (quantifiedVariables+=SMTSortedVariable+ (expression=SMTTerm | (expression=SMTTerm pattern=SMTTerm))) | ||
837 | */ | ||
838 | protected void sequence_SMTExists(EObject context, SMTExists semanticObject) { | ||
839 | genericSequencer.createSequence(context, semanticObject); | ||
840 | } | ||
841 | |||
842 | |||
843 | /** | ||
844 | * Constraint: | ||
845 | * probe=ReasoningProbe | ||
846 | */ | ||
847 | protected void sequence_SMTFailIfCombinator(EObject context, SMTFailIfCombinator semanticObject) { | ||
848 | if(errorAcceptor != null) { | ||
849 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_FAIL_IF_COMBINATOR__PROBE) == ValueTransient.YES) | ||
850 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_FAIL_IF_COMBINATOR__PROBE)); | ||
851 | } | ||
852 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
853 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
854 | feeder.accept(grammarAccess.getSMTFailIfCombinatorAccess().getProbeReasoningProbeParserRuleCall_2_0(), semanticObject.getProbe()); | ||
855 | feeder.finish(); | ||
856 | } | ||
857 | |||
858 | |||
859 | /** | ||
860 | * Constraint: | ||
861 | * (quantifiedVariables+=SMTSortedVariable+ (expression=SMTTerm | (expression=SMTTerm pattern=SMTTerm))) | ||
862 | */ | ||
863 | protected void sequence_SMTForall(EObject context, SMTForall semanticObject) { | ||
864 | genericSequencer.createSequence(context, semanticObject); | ||
865 | } | ||
866 | |||
867 | |||
868 | /** | ||
869 | * Constraint: | ||
870 | * (name=SMTID parameters+=SMTTypeReference* range=SMTTypeReference) | ||
871 | */ | ||
872 | protected void sequence_SMTFunctionDeclaration(EObject context, SMTFunctionDeclaration semanticObject) { | ||
873 | genericSequencer.createSequence(context, semanticObject); | ||
874 | } | ||
875 | |||
876 | |||
877 | /** | ||
878 | * Constraint: | ||
879 | * (name=SMTID parameters+=SMTSortedVariable* range=SMTTypeReference value=SMTTerm) | ||
880 | */ | ||
881 | protected void sequence_SMTFunctionDefinition(EObject context, SMTFunctionDefinition semanticObject) { | ||
882 | genericSequencer.createSequence(context, semanticObject); | ||
883 | } | ||
884 | |||
885 | |||
886 | /** | ||
887 | * Constraint: | ||
888 | * {SMTGetModelCommand} | ||
889 | */ | ||
890 | protected void sequence_SMTGetModelCommand(EObject context, SMTGetModelCommand semanticObject) { | ||
891 | genericSequencer.createSequence(context, semanticObject); | ||
892 | } | ||
893 | |||
894 | |||
895 | /** | ||
896 | * Constraint: | ||
897 | * (condition=SMTTerm if=SMTTerm else=SMTTerm) | ||
898 | */ | ||
899 | protected void sequence_SMTITE(EObject context, SMTITE semanticObject) { | ||
900 | if(errorAcceptor != null) { | ||
901 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTITE__CONDITION) == ValueTransient.YES) | ||
902 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTITE__CONDITION)); | ||
903 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTITE__IF) == ValueTransient.YES) | ||
904 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTITE__IF)); | ||
905 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTITE__ELSE) == ValueTransient.YES) | ||
906 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTITE__ELSE)); | ||
907 | } | ||
908 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
909 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
910 | feeder.accept(grammarAccess.getSMTITEAccess().getConditionSMTTermParserRuleCall_2_0(), semanticObject.getCondition()); | ||
911 | feeder.accept(grammarAccess.getSMTITEAccess().getIfSMTTermParserRuleCall_3_0(), semanticObject.getIf()); | ||
912 | feeder.accept(grammarAccess.getSMTITEAccess().getElseSMTTermParserRuleCall_4_0(), semanticObject.getElse()); | ||
913 | feeder.finish(); | ||
914 | } | ||
915 | |||
916 | |||
917 | /** | ||
918 | * Constraint: | ||
919 | * (probe=ReasoningProbe ifTactic=SMTReasoningTactic elseTactic=SMTReasoningTactic) | ||
920 | */ | ||
921 | protected void sequence_SMTIfCombinator(EObject context, SMTIfCombinator semanticObject) { | ||
922 | if(errorAcceptor != null) { | ||
923 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__PROBE) == ValueTransient.YES) | ||
924 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__PROBE)); | ||
925 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__IF_TACTIC) == ValueTransient.YES) | ||
926 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__IF_TACTIC)); | ||
927 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__ELSE_TACTIC) == ValueTransient.YES) | ||
928 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IF_COMBINATOR__ELSE_TACTIC)); | ||
929 | } | ||
930 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
931 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
932 | feeder.accept(grammarAccess.getSMTIfCombinatorAccess().getProbeReasoningProbeParserRuleCall_2_0(), semanticObject.getProbe()); | ||
933 | feeder.accept(grammarAccess.getSMTIfCombinatorAccess().getIfTacticSMTReasoningTacticParserRuleCall_3_0(), semanticObject.getIfTactic()); | ||
934 | feeder.accept(grammarAccess.getSMTIfCombinatorAccess().getElseTacticSMTReasoningTacticParserRuleCall_4_0(), semanticObject.getElseTactic()); | ||
935 | feeder.finish(); | ||
936 | } | ||
937 | |||
938 | |||
939 | /** | ||
940 | * Constraint: | ||
941 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
942 | */ | ||
943 | protected void sequence_SMTIff(EObject context, SMTIff semanticObject) { | ||
944 | if(errorAcceptor != null) { | ||
945 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IFF__LEFT_OPERAND) == ValueTransient.YES) | ||
946 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IFF__LEFT_OPERAND)); | ||
947 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IFF__RIGHT_OPERAND) == ValueTransient.YES) | ||
948 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IFF__RIGHT_OPERAND)); | ||
949 | } | ||
950 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
951 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
952 | feeder.accept(grammarAccess.getSMTIffAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
953 | feeder.accept(grammarAccess.getSMTIffAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
954 | feeder.finish(); | ||
955 | } | ||
956 | |||
957 | |||
958 | /** | ||
959 | * Constraint: | ||
960 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
961 | */ | ||
962 | protected void sequence_SMTImpl(EObject context, SMTImpl semanticObject) { | ||
963 | if(errorAcceptor != null) { | ||
964 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IMPL__LEFT_OPERAND) == ValueTransient.YES) | ||
965 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IMPL__LEFT_OPERAND)); | ||
966 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_IMPL__RIGHT_OPERAND) == ValueTransient.YES) | ||
967 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_IMPL__RIGHT_OPERAND)); | ||
968 | } | ||
969 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
970 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
971 | feeder.accept(grammarAccess.getSMTImplAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
972 | feeder.accept(grammarAccess.getSMTImplAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
973 | feeder.finish(); | ||
974 | } | ||
975 | |||
976 | |||
977 | /** | ||
978 | * Constraint: | ||
979 | * (name=SMTID definition=SMTTerm) | ||
980 | */ | ||
981 | protected void sequence_SMTInlineConstantDefinition(EObject context, SMTInlineConstantDefinition semanticObject) { | ||
982 | if(errorAcceptor != null) { | ||
983 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME) == ValueTransient.YES) | ||
984 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME)); | ||
985 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INLINE_CONSTANT_DEFINITION__DEFINITION) == ValueTransient.YES) | ||
986 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INLINE_CONSTANT_DEFINITION__DEFINITION)); | ||
987 | } | ||
988 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
989 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
990 | feeder.accept(grammarAccess.getSMTInlineConstantDefinitionAccess().getNameSMTIDParserRuleCall_1_0(), semanticObject.getName()); | ||
991 | feeder.accept(grammarAccess.getSMTInlineConstantDefinitionAccess().getDefinitionSMTTermParserRuleCall_2_0(), semanticObject.getDefinition()); | ||
992 | feeder.finish(); | ||
993 | } | ||
994 | |||
995 | |||
996 | /** | ||
997 | * Constraint: | ||
998 | * ( | ||
999 | * options+=SMTOption* | ||
1000 | * (typeDeclarations+=SMTType | functionDeclarations+=SMTFunctionDeclaration | functionDefinition+=SMTFunctionDefinition | assertions+=SMTAssertion)* | ||
1001 | * satCommand=SMTSatCommand | ||
1002 | * getModelCommand=SMTGetModelCommand | ||
1003 | * ) | ||
1004 | */ | ||
1005 | protected void sequence_SMTInput(EObject context, SMTInput semanticObject) { | ||
1006 | genericSequencer.createSequence(context, semanticObject); | ||
1007 | } | ||
1008 | |||
1009 | |||
1010 | /** | ||
1011 | * Constraint: | ||
1012 | * value=INT | ||
1013 | */ | ||
1014 | protected void sequence_SMTIntLiteral(EObject context, SMTIntLiteral semanticObject) { | ||
1015 | if(errorAcceptor != null) { | ||
1016 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_LITERAL__VALUE) == ValueTransient.YES) | ||
1017 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_LITERAL__VALUE)); | ||
1018 | } | ||
1019 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1020 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1021 | feeder.accept(grammarAccess.getSMTIntLiteralAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue()); | ||
1022 | feeder.finish(); | ||
1023 | } | ||
1024 | |||
1025 | |||
1026 | /** | ||
1027 | * Constraint: | ||
1028 | * {SMTIntTypeReference} | ||
1029 | */ | ||
1030 | protected void sequence_SMTIntTypeReference(EObject context, SMTIntTypeReference semanticObject) { | ||
1031 | genericSequencer.createSequence(context, semanticObject); | ||
1032 | } | ||
1033 | |||
1034 | |||
1035 | /** | ||
1036 | * Constraint: | ||
1037 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1038 | */ | ||
1039 | protected void sequence_SMTLEQ(EObject context, SMTLEQ semanticObject) { | ||
1040 | if(errorAcceptor != null) { | ||
1041 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTLEQ__LEFT_OPERAND) == ValueTransient.YES) | ||
1042 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTLEQ__LEFT_OPERAND)); | ||
1043 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTLEQ__RIGHT_OPERAND) == ValueTransient.YES) | ||
1044 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTLEQ__RIGHT_OPERAND)); | ||
1045 | } | ||
1046 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1047 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1048 | feeder.accept(grammarAccess.getSMTLEQAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1049 | feeder.accept(grammarAccess.getSMTLEQAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1050 | feeder.finish(); | ||
1051 | } | ||
1052 | |||
1053 | |||
1054 | /** | ||
1055 | * Constraint: | ||
1056 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1057 | */ | ||
1058 | protected void sequence_SMTLT(EObject context, SMTLT semanticObject) { | ||
1059 | if(errorAcceptor != null) { | ||
1060 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTLT__LEFT_OPERAND) == ValueTransient.YES) | ||
1061 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTLT__LEFT_OPERAND)); | ||
1062 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTLT__RIGHT_OPERAND) == ValueTransient.YES) | ||
1063 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTLT__RIGHT_OPERAND)); | ||
1064 | } | ||
1065 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1066 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1067 | feeder.accept(grammarAccess.getSMTLTAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1068 | feeder.accept(grammarAccess.getSMTLTAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1069 | feeder.finish(); | ||
1070 | } | ||
1071 | |||
1072 | |||
1073 | /** | ||
1074 | * Constraint: | ||
1075 | * (inlineConstantDefinitions+=SMTInlineConstantDefinition+ term=SMTTerm) | ||
1076 | */ | ||
1077 | protected void sequence_SMTLet(EObject context, SMTLet semanticObject) { | ||
1078 | genericSequencer.createSequence(context, semanticObject); | ||
1079 | } | ||
1080 | |||
1081 | |||
1082 | /** | ||
1083 | * Constraint: | ||
1084 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1085 | */ | ||
1086 | protected void sequence_SMTMEQ(EObject context, SMTMEQ semanticObject) { | ||
1087 | if(errorAcceptor != null) { | ||
1088 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTMEQ__LEFT_OPERAND) == ValueTransient.YES) | ||
1089 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTMEQ__LEFT_OPERAND)); | ||
1090 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTMEQ__RIGHT_OPERAND) == ValueTransient.YES) | ||
1091 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTMEQ__RIGHT_OPERAND)); | ||
1092 | } | ||
1093 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1094 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1095 | feeder.accept(grammarAccess.getSMTMEQAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1096 | feeder.accept(grammarAccess.getSMTMEQAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1097 | feeder.finish(); | ||
1098 | } | ||
1099 | |||
1100 | |||
1101 | /** | ||
1102 | * Constraint: | ||
1103 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1104 | */ | ||
1105 | protected void sequence_SMTMT(EObject context, SMTMT semanticObject) { | ||
1106 | if(errorAcceptor != null) { | ||
1107 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTMT__LEFT_OPERAND) == ValueTransient.YES) | ||
1108 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTMT__LEFT_OPERAND)); | ||
1109 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMTMT__RIGHT_OPERAND) == ValueTransient.YES) | ||
1110 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMTMT__RIGHT_OPERAND)); | ||
1111 | } | ||
1112 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1113 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1114 | feeder.accept(grammarAccess.getSMTMTAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1115 | feeder.accept(grammarAccess.getSMTMTAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1116 | feeder.finish(); | ||
1117 | } | ||
1118 | |||
1119 | |||
1120 | /** | ||
1121 | * Constraint: | ||
1122 | * (leftOperand=SMTTerm rightOperand=SMTTerm?) | ||
1123 | */ | ||
1124 | protected void sequence_SMTMinus(EObject context, SMTMinus semanticObject) { | ||
1125 | genericSequencer.createSequence(context, semanticObject); | ||
1126 | } | ||
1127 | |||
1128 | |||
1129 | /** | ||
1130 | * Constraint: | ||
1131 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1132 | */ | ||
1133 | protected void sequence_SMTMod(EObject context, SMTMod semanticObject) { | ||
1134 | if(errorAcceptor != null) { | ||
1135 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND) == ValueTransient.YES) | ||
1136 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND)); | ||
1137 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND) == ValueTransient.YES) | ||
1138 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND)); | ||
1139 | } | ||
1140 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1141 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1142 | feeder.accept(grammarAccess.getSMTModAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1143 | feeder.accept(grammarAccess.getSMTModAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1144 | feeder.finish(); | ||
1145 | } | ||
1146 | |||
1147 | |||
1148 | /** | ||
1149 | * Constraint: | ||
1150 | * ( | ||
1151 | * (newFunctionDeclarations+=SMTFunctionDeclaration | typeDefinitions+=SMTCardinalityConstraint | newFunctionDefinitions+=SMTFunctionDefinition)* | ||
1152 | * ) | ||
1153 | */ | ||
1154 | protected void sequence_SMTModelResult(EObject context, SMTModelResult semanticObject) { | ||
1155 | genericSequencer.createSequence(context, semanticObject); | ||
1156 | } | ||
1157 | |||
1158 | |||
1159 | /** | ||
1160 | * Constraint: | ||
1161 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1162 | */ | ||
1163 | protected void sequence_SMTMultiply(EObject context, SMTMultiply semanticObject) { | ||
1164 | if(errorAcceptor != null) { | ||
1165 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND) == ValueTransient.YES) | ||
1166 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND)); | ||
1167 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND) == ValueTransient.YES) | ||
1168 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND)); | ||
1169 | } | ||
1170 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1171 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1172 | feeder.accept(grammarAccess.getSMTMultiplyAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1173 | feeder.accept(grammarAccess.getSMTMultiplyAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1174 | feeder.finish(); | ||
1175 | } | ||
1176 | |||
1177 | |||
1178 | /** | ||
1179 | * Constraint: | ||
1180 | * operand=SMTTerm | ||
1181 | */ | ||
1182 | protected void sequence_SMTNot(EObject context, SMTNot semanticObject) { | ||
1183 | if(errorAcceptor != null) { | ||
1184 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_NOT__OPERAND) == ValueTransient.YES) | ||
1185 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_NOT__OPERAND)); | ||
1186 | } | ||
1187 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1188 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1189 | feeder.accept(grammarAccess.getSMTNotAccess().getOperandSMTTermParserRuleCall_2_0(), semanticObject.getOperand()); | ||
1190 | feeder.finish(); | ||
1191 | } | ||
1192 | |||
1193 | |||
1194 | /** | ||
1195 | * Constraint: | ||
1196 | * (name=PROPERTYNAME value=SMTAtomicTerm) | ||
1197 | */ | ||
1198 | protected void sequence_SMTOption(EObject context, SMTOption semanticObject) { | ||
1199 | if(errorAcceptor != null) { | ||
1200 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_OPTION__NAME) == ValueTransient.YES) | ||
1201 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_OPTION__NAME)); | ||
1202 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_OPTION__VALUE) == ValueTransient.YES) | ||
1203 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_OPTION__VALUE)); | ||
1204 | } | ||
1205 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1206 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1207 | feeder.accept(grammarAccess.getSMTOptionAccess().getNamePROPERTYNAMETerminalRuleCall_2_0(), semanticObject.getName()); | ||
1208 | feeder.accept(grammarAccess.getSMTOptionAccess().getValueSMTAtomicTermParserRuleCall_3_0(), semanticObject.getValue()); | ||
1209 | feeder.finish(); | ||
1210 | } | ||
1211 | |||
1212 | |||
1213 | /** | ||
1214 | * Constraint: | ||
1215 | * tactics+=SMTReasoningTactic+ | ||
1216 | */ | ||
1217 | protected void sequence_SMTOrElseCombinator(EObject context, SMTOrElseCombinator semanticObject) { | ||
1218 | genericSequencer.createSequence(context, semanticObject); | ||
1219 | } | ||
1220 | |||
1221 | |||
1222 | /** | ||
1223 | * Constraint: | ||
1224 | * operands+=SMTTerm+ | ||
1225 | */ | ||
1226 | protected void sequence_SMTOr(EObject context, SMTOr semanticObject) { | ||
1227 | genericSequencer.createSequence(context, semanticObject); | ||
1228 | } | ||
1229 | |||
1230 | |||
1231 | /** | ||
1232 | * Constraint: | ||
1233 | * (statistics=SMTStatisticsSection?) | ||
1234 | */ | ||
1235 | protected void sequence_SMTOutput(EObject context, SMTOutput semanticObject) { | ||
1236 | genericSequencer.createSequence(context, semanticObject); | ||
1237 | } | ||
1238 | |||
1239 | |||
1240 | /** | ||
1241 | * Constraint: | ||
1242 | * tactics+=SMTReasoningTactic+ | ||
1243 | */ | ||
1244 | protected void sequence_SMTParOrCombinator(EObject context, SMTParOrCombinator semanticObject) { | ||
1245 | genericSequencer.createSequence(context, semanticObject); | ||
1246 | } | ||
1247 | |||
1248 | |||
1249 | /** | ||
1250 | * Constraint: | ||
1251 | * (preProcessingTactic=SMTReasoningTactic paralellyPostpricessingTactic=SMTReasoningTactic) | ||
1252 | */ | ||
1253 | protected void sequence_SMTParThenCombinator(EObject context, SMTParThenCombinator semanticObject) { | ||
1254 | if(errorAcceptor != null) { | ||
1255 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_PAR_THEN_COMBINATOR__PRE_PROCESSING_TACTIC) == ValueTransient.YES) | ||
1256 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_PAR_THEN_COMBINATOR__PRE_PROCESSING_TACTIC)); | ||
1257 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_PAR_THEN_COMBINATOR__PARALELLY_POSTPRICESSING_TACTIC) == ValueTransient.YES) | ||
1258 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_PAR_THEN_COMBINATOR__PARALELLY_POSTPRICESSING_TACTIC)); | ||
1259 | } | ||
1260 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1261 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1262 | feeder.accept(grammarAccess.getSMTParThenCombinatorAccess().getPreProcessingTacticSMTReasoningTacticParserRuleCall_2_0(), semanticObject.getPreProcessingTactic()); | ||
1263 | feeder.accept(grammarAccess.getSMTParThenCombinatorAccess().getParalellyPostpricessingTacticSMTReasoningTacticParserRuleCall_3_0(), semanticObject.getParalellyPostpricessingTactic()); | ||
1264 | feeder.finish(); | ||
1265 | } | ||
1266 | |||
1267 | |||
1268 | /** | ||
1269 | * Constraint: | ||
1270 | * (leftOperand=SMTTerm rightOperand=SMTTerm) | ||
1271 | */ | ||
1272 | protected void sequence_SMTPlus(EObject context, SMTPlus semanticObject) { | ||
1273 | if(errorAcceptor != null) { | ||
1274 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND) == ValueTransient.YES) | ||
1275 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__LEFT_OPERAND)); | ||
1276 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND) == ValueTransient.YES) | ||
1277 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_INT_OPERATION__RIGHT_OPERAND)); | ||
1278 | } | ||
1279 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1280 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1281 | feeder.accept(grammarAccess.getSMTPlusAccess().getLeftOperandSMTTermParserRuleCall_2_0(), semanticObject.getLeftOperand()); | ||
1282 | feeder.accept(grammarAccess.getSMTPlusAccess().getRightOperandSMTTermParserRuleCall_3_0(), semanticObject.getRightOperand()); | ||
1283 | feeder.finish(); | ||
1284 | } | ||
1285 | |||
1286 | |||
1287 | /** | ||
1288 | * Constraint: | ||
1289 | * value=REAL | ||
1290 | */ | ||
1291 | protected void sequence_SMTRealLiteral(EObject context, SMTRealLiteral semanticObject) { | ||
1292 | if(errorAcceptor != null) { | ||
1293 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_REAL_LITERAL__VALUE) == ValueTransient.YES) | ||
1294 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_REAL_LITERAL__VALUE)); | ||
1295 | } | ||
1296 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1297 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1298 | feeder.accept(grammarAccess.getSMTRealLiteralAccess().getValueREALTerminalRuleCall_0(), semanticObject.getValue()); | ||
1299 | feeder.finish(); | ||
1300 | } | ||
1301 | |||
1302 | |||
1303 | /** | ||
1304 | * Constraint: | ||
1305 | * {SMTRealTypeReference} | ||
1306 | */ | ||
1307 | protected void sequence_SMTRealTypeReference(EObject context, SMTRealTypeReference semanticObject) { | ||
1308 | genericSequencer.createSequence(context, semanticObject); | ||
1309 | } | ||
1310 | |||
1311 | |||
1312 | /** | ||
1313 | * Constraint: | ||
1314 | * (sat?='sat' | unsat?='unsat' | unknown?='unknown') | ||
1315 | */ | ||
1316 | protected void sequence_SMTSatResult(EObject context, SMTSatResult semanticObject) { | ||
1317 | genericSequencer.createSequence(context, semanticObject); | ||
1318 | } | ||
1319 | |||
1320 | |||
1321 | /** | ||
1322 | * Constraint: | ||
1323 | * name=SMTID | ||
1324 | */ | ||
1325 | protected void sequence_SMTSetTypeDeclaration(EObject context, SMTSetTypeDeclaration semanticObject) { | ||
1326 | if(errorAcceptor != null) { | ||
1327 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_TYPE__NAME) == ValueTransient.YES) | ||
1328 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_TYPE__NAME)); | ||
1329 | } | ||
1330 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1331 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1332 | feeder.accept(grammarAccess.getSMTSetTypeDeclarationAccess().getNameSMTIDParserRuleCall_2_0(), semanticObject.getName()); | ||
1333 | feeder.finish(); | ||
1334 | } | ||
1335 | |||
1336 | |||
1337 | /** | ||
1338 | * Constraint: | ||
1339 | * {SMTSimpleSatCommand} | ||
1340 | */ | ||
1341 | protected void sequence_SMTSimpleSatCommand(EObject context, SMTSimpleSatCommand semanticObject) { | ||
1342 | genericSequencer.createSequence(context, semanticObject); | ||
1343 | } | ||
1344 | |||
1345 | |||
1346 | /** | ||
1347 | * Constraint: | ||
1348 | * (name=SMTID range=SMTTypeReference) | ||
1349 | */ | ||
1350 | protected void sequence_SMTSortedVariable(EObject context, SMTSortedVariable semanticObject) { | ||
1351 | if(errorAcceptor != null) { | ||
1352 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME) == ValueTransient.YES) | ||
1353 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_SYMBOLIC_DECLARATION__NAME)); | ||
1354 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_SORTED_VARIABLE__RANGE) == ValueTransient.YES) | ||
1355 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_SORTED_VARIABLE__RANGE)); | ||
1356 | } | ||
1357 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1358 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1359 | feeder.accept(grammarAccess.getSMTSortedVariableAccess().getNameSMTIDParserRuleCall_1_0(), semanticObject.getName()); | ||
1360 | feeder.accept(grammarAccess.getSMTSortedVariableAccess().getRangeSMTTypeReferenceParserRuleCall_2_0(), semanticObject.getRange()); | ||
1361 | feeder.finish(); | ||
1362 | } | ||
1363 | |||
1364 | |||
1365 | /** | ||
1366 | * Constraint: | ||
1367 | * (name=PROPERTYNAME value=REAL) | ||
1368 | */ | ||
1369 | protected void sequence_SMTStatisticDoubleValue(EObject context, SMTStatisticDoubleValue semanticObject) { | ||
1370 | if(errorAcceptor != null) { | ||
1371 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_VALUE__NAME) == ValueTransient.YES) | ||
1372 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_VALUE__NAME)); | ||
1373 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_DOUBLE_VALUE__VALUE) == ValueTransient.YES) | ||
1374 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_DOUBLE_VALUE__VALUE)); | ||
1375 | } | ||
1376 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1377 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1378 | feeder.accept(grammarAccess.getSMTStatisticDoubleValueAccess().getNamePROPERTYNAMETerminalRuleCall_0_0(), semanticObject.getName()); | ||
1379 | feeder.accept(grammarAccess.getSMTStatisticDoubleValueAccess().getValueREALTerminalRuleCall_1_0(), semanticObject.getValue()); | ||
1380 | feeder.finish(); | ||
1381 | } | ||
1382 | |||
1383 | |||
1384 | /** | ||
1385 | * Constraint: | ||
1386 | * (name=PROPERTYNAME value=INT) | ||
1387 | */ | ||
1388 | protected void sequence_SMTStatisticIntValue(EObject context, SMTStatisticIntValue semanticObject) { | ||
1389 | if(errorAcceptor != null) { | ||
1390 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_VALUE__NAME) == ValueTransient.YES) | ||
1391 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_VALUE__NAME)); | ||
1392 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_INT_VALUE__VALUE) == ValueTransient.YES) | ||
1393 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_STATISTIC_INT_VALUE__VALUE)); | ||
1394 | } | ||
1395 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1396 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1397 | feeder.accept(grammarAccess.getSMTStatisticIntValueAccess().getNamePROPERTYNAMETerminalRuleCall_0_0(), semanticObject.getName()); | ||
1398 | feeder.accept(grammarAccess.getSMTStatisticIntValueAccess().getValueINTTerminalRuleCall_1_0(), semanticObject.getValue()); | ||
1399 | feeder.finish(); | ||
1400 | } | ||
1401 | |||
1402 | |||
1403 | /** | ||
1404 | * Constraint: | ||
1405 | * (values+=SMTStatisticValue*) | ||
1406 | */ | ||
1407 | protected void sequence_SMTStatisticsSection(EObject context, SMTStatisticsSection semanticObject) { | ||
1408 | genericSequencer.createSequence(context, semanticObject); | ||
1409 | } | ||
1410 | |||
1411 | |||
1412 | /** | ||
1413 | * Constraint: | ||
1414 | * ((symbolicReference=[SMTSymbolicDeclaration|ID] parameterSubstitutions+=SMTTerm+) | symbolicReference=[SMTSymbolicDeclaration|ID]) | ||
1415 | */ | ||
1416 | protected void sequence_SMTSymbolicValue(EObject context, SMTSymbolicValue semanticObject) { | ||
1417 | genericSequencer.createSequence(context, semanticObject); | ||
1418 | } | ||
1419 | |||
1420 | |||
1421 | /** | ||
1422 | * Constraint: | ||
1423 | * (tactic=SMTReasoningTactic time=INT) | ||
1424 | */ | ||
1425 | protected void sequence_SMTTryForCombinator(EObject context, SMTTryForCombinator semanticObject) { | ||
1426 | if(errorAcceptor != null) { | ||
1427 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_TRY_FOR_COMBINATOR__TACTIC) == ValueTransient.YES) | ||
1428 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_TRY_FOR_COMBINATOR__TACTIC)); | ||
1429 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_TRY_FOR_COMBINATOR__TIME) == ValueTransient.YES) | ||
1430 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_TRY_FOR_COMBINATOR__TIME)); | ||
1431 | } | ||
1432 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1433 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1434 | feeder.accept(grammarAccess.getSMTTryForCombinatorAccess().getTacticSMTReasoningTacticParserRuleCall_2_0(), semanticObject.getTactic()); | ||
1435 | feeder.accept(grammarAccess.getSMTTryForCombinatorAccess().getTimeINTTerminalRuleCall_3_0(), semanticObject.getTime()); | ||
1436 | feeder.finish(); | ||
1437 | } | ||
1438 | |||
1439 | |||
1440 | /** | ||
1441 | * Constraint: | ||
1442 | * command=ID | ||
1443 | */ | ||
1444 | protected void sequence_SMTUnsupportedResult(EObject context, SMTUnsupportedResult semanticObject) { | ||
1445 | if(errorAcceptor != null) { | ||
1446 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_UNSUPPORTED_RESULT__COMMAND) == ValueTransient.YES) | ||
1447 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_UNSUPPORTED_RESULT__COMMAND)); | ||
1448 | } | ||
1449 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1450 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1451 | feeder.accept(grammarAccess.getSMTUnsupportedResultAccess().getCommandIDTerminalRuleCall_2_0(), semanticObject.getCommand()); | ||
1452 | feeder.finish(); | ||
1453 | } | ||
1454 | |||
1455 | |||
1456 | /** | ||
1457 | * Constraint: | ||
1458 | * (tactic=SMTReasoningTactic parameters+=ReasoningTacticParameter*) | ||
1459 | */ | ||
1460 | protected void sequence_SMTUsingParamCombinator(EObject context, SMTUsingParamCombinator semanticObject) { | ||
1461 | genericSequencer.createSequence(context, semanticObject); | ||
1462 | } | ||
1463 | |||
1464 | |||
1465 | /** | ||
1466 | * Constraint: | ||
1467 | * (probe=ReasoningProbe tactic=SMTReasoningTactic) | ||
1468 | */ | ||
1469 | protected void sequence_SMTWhenCombinator(EObject context, SMTWhenCombinator semanticObject) { | ||
1470 | if(errorAcceptor != null) { | ||
1471 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_WHEN_COMBINATOR__PROBE) == ValueTransient.YES) | ||
1472 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_WHEN_COMBINATOR__PROBE)); | ||
1473 | if(transientValues.isValueTransient(semanticObject, SmtLanguagePackage.Literals.SMT_WHEN_COMBINATOR__TACTIC) == ValueTransient.YES) | ||
1474 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SmtLanguagePackage.Literals.SMT_WHEN_COMBINATOR__TACTIC)); | ||
1475 | } | ||
1476 | INodesForEObjectProvider nodes = createNodeProvider(semanticObject); | ||
1477 | SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); | ||
1478 | feeder.accept(grammarAccess.getSMTWhenCombinatorAccess().getProbeReasoningProbeParserRuleCall_2_0(), semanticObject.getProbe()); | ||
1479 | feeder.accept(grammarAccess.getSMTWhenCombinatorAccess().getTacticSMTReasoningTacticParserRuleCall_3_0(), semanticObject.getTactic()); | ||
1480 | feeder.finish(); | ||
1481 | } | ||
1482 | } | ||