diff options
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse')
197 files changed, 33193 insertions, 18420 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java index cbf67ff9..4bf254b2 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language; | 4 | package org.eclipse.viatra.solver.language; |
| 5 | 5 | ||
| @@ -10,7 +10,7 @@ import java.util.Properties; | |||
| 10 | import org.eclipse.viatra.solver.language.generator.SolverLanguageGenerator; | 10 | import org.eclipse.viatra.solver.language.generator.SolverLanguageGenerator; |
| 11 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageAntlrTokenFileProvider; | 11 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageAntlrTokenFileProvider; |
| 12 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser; | 12 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser; |
| 13 | import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageLexer; | 13 | import org.eclipse.viatra.solver.language.parser.antlr.lexer.InternalSolverLanguageLexer; |
| 14 | import org.eclipse.viatra.solver.language.scoping.SolverLanguageScopeProvider; | 14 | import org.eclipse.viatra.solver.language.scoping.SolverLanguageScopeProvider; |
| 15 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSemanticSequencer; | 15 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSemanticSequencer; |
| 16 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer; | 16 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer; |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin index c999caec..da698ba6 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin | |||
| Binary files differ | |||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java index 91347850..33c82701 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language; | 4 | package org.eclipse.viatra.solver.language; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java index 059473c8..cfddb988 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.parser.antlr; | 4 | package org.eclipse.viatra.solver.language.parser.antlr; |
| 5 | 5 | ||
| @@ -11,6 +11,6 @@ public class SolverLanguageAntlrTokenFileProvider implements IAntlrTokenFileProv | |||
| 11 | @Override | 11 | @Override |
| 12 | public InputStream getAntlrTokenFile() { | 12 | public InputStream getAntlrTokenFile() { |
| 13 | ClassLoader classLoader = getClass().getClassLoader(); | 13 | ClassLoader classLoader = getClass().getClassLoader(); |
| 14 | return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens"); | 14 | return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens"); |
| 15 | } | 15 | } |
| 16 | } | 16 | } |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java index 7155770e..da897406 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java | |||
| @@ -1,9 +1,11 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.parser.antlr; | 4 | package org.eclipse.viatra.solver.language.parser.antlr; |
| 5 | 5 | ||
| 6 | import com.google.inject.Inject; | 6 | import com.google.inject.Inject; |
| 7 | import org.antlr.runtime.CharStream; | ||
| 8 | import org.antlr.runtime.TokenSource; | ||
| 7 | import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser; | 9 | import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser; |
| 8 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | 10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; |
| 9 | import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; | 11 | import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; |
| @@ -19,6 +21,19 @@ public class SolverLanguageParser extends AbstractAntlrParser { | |||
| 19 | tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); | 21 | tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); |
| 20 | } | 22 | } |
| 21 | 23 | ||
| 24 | @Override | ||
| 25 | protected TokenSource createLexer(CharStream stream) { | ||
| 26 | return new SolverLanguageTokenSource(super.createLexer(stream)); | ||
| 27 | } | ||
| 28 | |||
| 29 | /** | ||
| 30 | * Indentation aware languages do not support partial parsing since the lexer is inherently stateful. | ||
| 31 | * Override and return {@code true} if your terminal splitting is stateless. | ||
| 32 | */ | ||
| 33 | @Override | ||
| 34 | protected boolean isReparseSupported() { | ||
| 35 | return false; | ||
| 36 | } | ||
| 22 | 37 | ||
| 23 | @Override | 38 | @Override |
| 24 | protected InternalSolverLanguageParser createParser(XtextTokenStream stream) { | 39 | protected InternalSolverLanguageParser createParser(XtextTokenStream stream) { |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g deleted file mode 100644 index 501e2e59..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g +++ /dev/null | |||
| @@ -1,2509 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | grammar InternalSolverLanguage; | ||
| 5 | |||
| 6 | options { | ||
| 7 | superClass=AbstractInternalAntlrParser; | ||
| 8 | } | ||
| 9 | |||
| 10 | @lexer::header { | ||
| 11 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 12 | |||
| 13 | // Hack: Use our own Lexer superclass by means of import. | ||
| 14 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 15 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 16 | } | ||
| 17 | |||
| 18 | @parser::header { | ||
| 19 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 20 | |||
| 21 | import org.eclipse.xtext.*; | ||
| 22 | import org.eclipse.xtext.parser.*; | ||
| 23 | import org.eclipse.xtext.parser.impl.*; | ||
| 24 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
| 25 | import org.eclipse.emf.ecore.EObject; | ||
| 26 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
| 27 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
| 28 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
| 29 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
| 30 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
| 31 | |||
| 32 | } | ||
| 33 | |||
| 34 | @parser::members { | ||
| 35 | |||
| 36 | private SolverLanguageGrammarAccess grammarAccess; | ||
| 37 | |||
| 38 | public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { | ||
| 39 | this(input); | ||
| 40 | this.grammarAccess = grammarAccess; | ||
| 41 | registerRules(grammarAccess.getGrammar()); | ||
| 42 | } | ||
| 43 | |||
| 44 | @Override | ||
| 45 | protected String getFirstRuleName() { | ||
| 46 | return "Problem"; | ||
| 47 | } | ||
| 48 | |||
| 49 | @Override | ||
| 50 | protected SolverLanguageGrammarAccess getGrammarAccess() { | ||
| 51 | return grammarAccess; | ||
| 52 | } | ||
| 53 | |||
| 54 | } | ||
| 55 | |||
| 56 | @rulecatch { | ||
| 57 | catch (RecognitionException re) { | ||
| 58 | recover(input,re); | ||
| 59 | appendSkippedTokens(); | ||
| 60 | } | ||
| 61 | } | ||
| 62 | |||
| 63 | // Entry rule entryRuleProblem | ||
| 64 | entryRuleProblem returns [EObject current=null]: | ||
| 65 | { newCompositeNode(grammarAccess.getProblemRule()); } | ||
| 66 | iv_ruleProblem=ruleProblem | ||
| 67 | { $current=$iv_ruleProblem.current; } | ||
| 68 | EOF; | ||
| 69 | |||
| 70 | // Rule Problem | ||
| 71 | ruleProblem returns [EObject current=null] | ||
| 72 | @init { | ||
| 73 | enterRule(); | ||
| 74 | } | ||
| 75 | @after { | ||
| 76 | leaveRule(); | ||
| 77 | }: | ||
| 78 | ( | ||
| 79 | ( | ||
| 80 | { | ||
| 81 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | ||
| 82 | } | ||
| 83 | lv_statements_0_0=ruleStatement | ||
| 84 | { | ||
| 85 | if ($current==null) { | ||
| 86 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
| 87 | } | ||
| 88 | add( | ||
| 89 | $current, | ||
| 90 | "statements", | ||
| 91 | lv_statements_0_0, | ||
| 92 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
| 93 | afterParserOrEnumRuleCall(); | ||
| 94 | } | ||
| 95 | ) | ||
| 96 | )* | ||
| 97 | ; | ||
| 98 | |||
| 99 | // Entry rule entryRuleStatement | ||
| 100 | entryRuleStatement returns [EObject current=null]: | ||
| 101 | { newCompositeNode(grammarAccess.getStatementRule()); } | ||
| 102 | iv_ruleStatement=ruleStatement | ||
| 103 | { $current=$iv_ruleStatement.current; } | ||
| 104 | EOF; | ||
| 105 | |||
| 106 | // Rule Statement | ||
| 107 | ruleStatement returns [EObject current=null] | ||
| 108 | @init { | ||
| 109 | enterRule(); | ||
| 110 | } | ||
| 111 | @after { | ||
| 112 | leaveRule(); | ||
| 113 | }: | ||
| 114 | ( | ||
| 115 | { | ||
| 116 | newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); | ||
| 117 | } | ||
| 118 | this_Interpretation_0=ruleInterpretation | ||
| 119 | { | ||
| 120 | $current = $this_Interpretation_0.current; | ||
| 121 | afterParserOrEnumRuleCall(); | ||
| 122 | } | ||
| 123 | | | ||
| 124 | { | ||
| 125 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); | ||
| 126 | } | ||
| 127 | this_Predicate_1=rulePredicate | ||
| 128 | { | ||
| 129 | $current = $this_Predicate_1.current; | ||
| 130 | afterParserOrEnumRuleCall(); | ||
| 131 | } | ||
| 132 | ) | ||
| 133 | ; | ||
| 134 | |||
| 135 | // Entry rule entryRuleREALLiteral | ||
| 136 | entryRuleREALLiteral returns [String current=null]: | ||
| 137 | { newCompositeNode(grammarAccess.getREALLiteralRule()); } | ||
| 138 | iv_ruleREALLiteral=ruleREALLiteral | ||
| 139 | { $current=$iv_ruleREALLiteral.current.getText(); } | ||
| 140 | EOF; | ||
| 141 | |||
| 142 | // Rule REALLiteral | ||
| 143 | ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 144 | @init { | ||
| 145 | enterRule(); | ||
| 146 | } | ||
| 147 | @after { | ||
| 148 | leaveRule(); | ||
| 149 | }: | ||
| 150 | ( | ||
| 151 | ( | ||
| 152 | kw='-' | ||
| 153 | { | ||
| 154 | $current.merge(kw); | ||
| 155 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); | ||
| 156 | } | ||
| 157 | )? | ||
| 158 | this_INT_1=RULE_INT | ||
| 159 | { | ||
| 160 | $current.merge(this_INT_1); | ||
| 161 | } | ||
| 162 | { | ||
| 163 | newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); | ||
| 164 | } | ||
| 165 | kw='.' | ||
| 166 | { | ||
| 167 | $current.merge(kw); | ||
| 168 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); | ||
| 169 | } | ||
| 170 | this_INT_3=RULE_INT | ||
| 171 | { | ||
| 172 | $current.merge(this_INT_3); | ||
| 173 | } | ||
| 174 | { | ||
| 175 | newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); | ||
| 176 | } | ||
| 177 | ) | ||
| 178 | ; | ||
| 179 | |||
| 180 | // Entry rule entryRuleINTLiteral | ||
| 181 | entryRuleINTLiteral returns [String current=null]: | ||
| 182 | { newCompositeNode(grammarAccess.getINTLiteralRule()); } | ||
| 183 | iv_ruleINTLiteral=ruleINTLiteral | ||
| 184 | { $current=$iv_ruleINTLiteral.current.getText(); } | ||
| 185 | EOF; | ||
| 186 | |||
| 187 | // Rule INTLiteral | ||
| 188 | ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 189 | @init { | ||
| 190 | enterRule(); | ||
| 191 | } | ||
| 192 | @after { | ||
| 193 | leaveRule(); | ||
| 194 | }: | ||
| 195 | ( | ||
| 196 | ( | ||
| 197 | kw='-' | ||
| 198 | { | ||
| 199 | $current.merge(kw); | ||
| 200 | newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); | ||
| 201 | } | ||
| 202 | )? | ||
| 203 | this_INT_1=RULE_INT | ||
| 204 | { | ||
| 205 | $current.merge(this_INT_1); | ||
| 206 | } | ||
| 207 | { | ||
| 208 | newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); | ||
| 209 | } | ||
| 210 | ) | ||
| 211 | ; | ||
| 212 | |||
| 213 | // Entry rule entryRuleBooleanValue | ||
| 214 | entryRuleBooleanValue returns [EObject current=null]: | ||
| 215 | { newCompositeNode(grammarAccess.getBooleanValueRule()); } | ||
| 216 | iv_ruleBooleanValue=ruleBooleanValue | ||
| 217 | { $current=$iv_ruleBooleanValue.current; } | ||
| 218 | EOF; | ||
| 219 | |||
| 220 | // Rule BooleanValue | ||
| 221 | ruleBooleanValue returns [EObject current=null] | ||
| 222 | @init { | ||
| 223 | enterRule(); | ||
| 224 | } | ||
| 225 | @after { | ||
| 226 | leaveRule(); | ||
| 227 | }: | ||
| 228 | ( | ||
| 229 | ( | ||
| 230 | ( | ||
| 231 | { | ||
| 232 | $current = forceCreateModelElement( | ||
| 233 | grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), | ||
| 234 | $current); | ||
| 235 | } | ||
| 236 | ) | ||
| 237 | otherlv_1='true' | ||
| 238 | { | ||
| 239 | newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); | ||
| 240 | } | ||
| 241 | ) | ||
| 242 | | | ||
| 243 | ( | ||
| 244 | otherlv_2='false' | ||
| 245 | { | ||
| 246 | newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); | ||
| 247 | } | ||
| 248 | ( | ||
| 249 | { | ||
| 250 | $current = forceCreateModelElement( | ||
| 251 | grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), | ||
| 252 | $current); | ||
| 253 | } | ||
| 254 | ) | ||
| 255 | ) | ||
| 256 | ) | ||
| 257 | ; | ||
| 258 | |||
| 259 | // Entry rule entryRuleTruthValue | ||
| 260 | entryRuleTruthValue returns [EObject current=null]: | ||
| 261 | { newCompositeNode(grammarAccess.getTruthValueRule()); } | ||
| 262 | iv_ruleTruthValue=ruleTruthValue | ||
| 263 | { $current=$iv_ruleTruthValue.current; } | ||
| 264 | EOF; | ||
| 265 | |||
| 266 | // Rule TruthValue | ||
| 267 | ruleTruthValue returns [EObject current=null] | ||
| 268 | @init { | ||
| 269 | enterRule(); | ||
| 270 | } | ||
| 271 | @after { | ||
| 272 | leaveRule(); | ||
| 273 | }: | ||
| 274 | ( | ||
| 275 | ( | ||
| 276 | ( | ||
| 277 | { | ||
| 278 | $current = forceCreateModelElement( | ||
| 279 | grammarAccess.getTruthValueAccess().getTrueAction_0_0(), | ||
| 280 | $current); | ||
| 281 | } | ||
| 282 | ) | ||
| 283 | otherlv_1='true' | ||
| 284 | { | ||
| 285 | newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); | ||
| 286 | } | ||
| 287 | ) | ||
| 288 | | | ||
| 289 | ( | ||
| 290 | ( | ||
| 291 | { | ||
| 292 | $current = forceCreateModelElement( | ||
| 293 | grammarAccess.getTruthValueAccess().getFalseAction_1_0(), | ||
| 294 | $current); | ||
| 295 | } | ||
| 296 | ) | ||
| 297 | otherlv_3='false' | ||
| 298 | { | ||
| 299 | newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); | ||
| 300 | } | ||
| 301 | ) | ||
| 302 | | | ||
| 303 | ( | ||
| 304 | ( | ||
| 305 | { | ||
| 306 | $current = forceCreateModelElement( | ||
| 307 | grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), | ||
| 308 | $current); | ||
| 309 | } | ||
| 310 | ) | ||
| 311 | otherlv_5='unknown' | ||
| 312 | { | ||
| 313 | newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); | ||
| 314 | } | ||
| 315 | ) | ||
| 316 | | | ||
| 317 | ( | ||
| 318 | ( | ||
| 319 | { | ||
| 320 | $current = forceCreateModelElement( | ||
| 321 | grammarAccess.getTruthValueAccess().getErrorAction_3_0(), | ||
| 322 | $current); | ||
| 323 | } | ||
| 324 | ) | ||
| 325 | otherlv_7='error' | ||
| 326 | { | ||
| 327 | newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); | ||
| 328 | } | ||
| 329 | ) | ||
| 330 | ) | ||
| 331 | ; | ||
| 332 | |||
| 333 | // Entry rule entryRuleInterpretation | ||
| 334 | entryRuleInterpretation returns [EObject current=null]: | ||
| 335 | { newCompositeNode(grammarAccess.getInterpretationRule()); } | ||
| 336 | iv_ruleInterpretation=ruleInterpretation | ||
| 337 | { $current=$iv_ruleInterpretation.current; } | ||
| 338 | EOF; | ||
| 339 | |||
| 340 | // Rule Interpretation | ||
| 341 | ruleInterpretation returns [EObject current=null] | ||
| 342 | @init { | ||
| 343 | enterRule(); | ||
| 344 | } | ||
| 345 | @after { | ||
| 346 | leaveRule(); | ||
| 347 | }: | ||
| 348 | ( | ||
| 349 | { | ||
| 350 | newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); | ||
| 351 | } | ||
| 352 | this_BasicInterpretation_0=ruleBasicInterpretation | ||
| 353 | { | ||
| 354 | $current = $this_BasicInterpretation_0.current; | ||
| 355 | afterParserOrEnumRuleCall(); | ||
| 356 | } | ||
| 357 | | | ||
| 358 | { | ||
| 359 | newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); | ||
| 360 | } | ||
| 361 | this_DefaultInterpretation_1=ruleDefaultInterpretation | ||
| 362 | { | ||
| 363 | $current = $this_DefaultInterpretation_1.current; | ||
| 364 | afterParserOrEnumRuleCall(); | ||
| 365 | } | ||
| 366 | | | ||
| 367 | { | ||
| 368 | newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); | ||
| 369 | } | ||
| 370 | this_CDInterpretation_2=ruleCDInterpretation | ||
| 371 | { | ||
| 372 | $current = $this_CDInterpretation_2.current; | ||
| 373 | afterParserOrEnumRuleCall(); | ||
| 374 | } | ||
| 375 | ) | ||
| 376 | ; | ||
| 377 | |||
| 378 | // Entry rule entryRuleBasicInterpretation | ||
| 379 | entryRuleBasicInterpretation returns [EObject current=null]: | ||
| 380 | { newCompositeNode(grammarAccess.getBasicInterpretationRule()); } | ||
| 381 | iv_ruleBasicInterpretation=ruleBasicInterpretation | ||
| 382 | { $current=$iv_ruleBasicInterpretation.current; } | ||
| 383 | EOF; | ||
| 384 | |||
| 385 | // Rule BasicInterpretation | ||
| 386 | ruleBasicInterpretation returns [EObject current=null] | ||
| 387 | @init { | ||
| 388 | enterRule(); | ||
| 389 | } | ||
| 390 | @after { | ||
| 391 | leaveRule(); | ||
| 392 | }: | ||
| 393 | ( | ||
| 394 | ( | ||
| 395 | ( | ||
| 396 | { | ||
| 397 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); | ||
| 398 | } | ||
| 399 | lv_symbol_0_0=ruleSymbol | ||
| 400 | { | ||
| 401 | if ($current==null) { | ||
| 402 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 403 | } | ||
| 404 | set( | ||
| 405 | $current, | ||
| 406 | "symbol", | ||
| 407 | lv_symbol_0_0, | ||
| 408 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 409 | afterParserOrEnumRuleCall(); | ||
| 410 | } | ||
| 411 | ) | ||
| 412 | ) | ||
| 413 | ( | ||
| 414 | otherlv_1='(' | ||
| 415 | { | ||
| 416 | newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); | ||
| 417 | } | ||
| 418 | ( | ||
| 419 | ( | ||
| 420 | ( | ||
| 421 | { | ||
| 422 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); | ||
| 423 | } | ||
| 424 | lv_objects_2_0=ruleComplexObject | ||
| 425 | { | ||
| 426 | if ($current==null) { | ||
| 427 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 428 | } | ||
| 429 | add( | ||
| 430 | $current, | ||
| 431 | "objects", | ||
| 432 | lv_objects_2_0, | ||
| 433 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 434 | afterParserOrEnumRuleCall(); | ||
| 435 | } | ||
| 436 | ) | ||
| 437 | ) | ||
| 438 | ( | ||
| 439 | otherlv_3=',' | ||
| 440 | { | ||
| 441 | newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); | ||
| 442 | } | ||
| 443 | ( | ||
| 444 | ( | ||
| 445 | { | ||
| 446 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); | ||
| 447 | } | ||
| 448 | lv_objects_4_0=ruleComplexObject | ||
| 449 | { | ||
| 450 | if ($current==null) { | ||
| 451 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 452 | } | ||
| 453 | add( | ||
| 454 | $current, | ||
| 455 | "objects", | ||
| 456 | lv_objects_4_0, | ||
| 457 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 458 | afterParserOrEnumRuleCall(); | ||
| 459 | } | ||
| 460 | ) | ||
| 461 | ) | ||
| 462 | )* | ||
| 463 | )? | ||
| 464 | otherlv_5=')' | ||
| 465 | { | ||
| 466 | newLeafNode(otherlv_5, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); | ||
| 467 | } | ||
| 468 | )? | ||
| 469 | otherlv_6=':' | ||
| 470 | { | ||
| 471 | newLeafNode(otherlv_6, grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); | ||
| 472 | } | ||
| 473 | ( | ||
| 474 | ( | ||
| 475 | { | ||
| 476 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); | ||
| 477 | } | ||
| 478 | lv_value_7_0=ruleTruthValue | ||
| 479 | { | ||
| 480 | if ($current==null) { | ||
| 481 | $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 482 | } | ||
| 483 | set( | ||
| 484 | $current, | ||
| 485 | "value", | ||
| 486 | lv_value_7_0, | ||
| 487 | "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | ||
| 488 | afterParserOrEnumRuleCall(); | ||
| 489 | } | ||
| 490 | ) | ||
| 491 | ) | ||
| 492 | ) | ||
| 493 | ; | ||
| 494 | |||
| 495 | // Entry rule entryRuleSymbol | ||
| 496 | entryRuleSymbol returns [EObject current=null]: | ||
| 497 | { newCompositeNode(grammarAccess.getSymbolRule()); } | ||
| 498 | iv_ruleSymbol=ruleSymbol | ||
| 499 | { $current=$iv_ruleSymbol.current; } | ||
| 500 | EOF; | ||
| 501 | |||
| 502 | // Rule Symbol | ||
| 503 | ruleSymbol returns [EObject current=null] | ||
| 504 | @init { | ||
| 505 | enterRule(); | ||
| 506 | } | ||
| 507 | @after { | ||
| 508 | leaveRule(); | ||
| 509 | }: | ||
| 510 | ( | ||
| 511 | { | ||
| 512 | newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); | ||
| 513 | } | ||
| 514 | this_ModelSymbol_0=ruleModelSymbol | ||
| 515 | { | ||
| 516 | $current = $this_ModelSymbol_0.current; | ||
| 517 | afterParserOrEnumRuleCall(); | ||
| 518 | } | ||
| 519 | | | ||
| 520 | { | ||
| 521 | newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); | ||
| 522 | } | ||
| 523 | this_PartialitySymbol_1=rulePartialitySymbol | ||
| 524 | { | ||
| 525 | $current = $this_PartialitySymbol_1.current; | ||
| 526 | afterParserOrEnumRuleCall(); | ||
| 527 | } | ||
| 528 | | | ||
| 529 | { | ||
| 530 | newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); | ||
| 531 | } | ||
| 532 | this_DataSymbol_2=ruleDataSymbol | ||
| 533 | { | ||
| 534 | $current = $this_DataSymbol_2.current; | ||
| 535 | afterParserOrEnumRuleCall(); | ||
| 536 | } | ||
| 537 | ) | ||
| 538 | ; | ||
| 539 | |||
| 540 | // Entry rule entryRuleModelSymbol | ||
| 541 | entryRuleModelSymbol returns [EObject current=null]: | ||
| 542 | { newCompositeNode(grammarAccess.getModelSymbolRule()); } | ||
| 543 | iv_ruleModelSymbol=ruleModelSymbol | ||
| 544 | { $current=$iv_ruleModelSymbol.current; } | ||
| 545 | EOF; | ||
| 546 | |||
| 547 | // Rule ModelSymbol | ||
| 548 | ruleModelSymbol returns [EObject current=null] | ||
| 549 | @init { | ||
| 550 | enterRule(); | ||
| 551 | } | ||
| 552 | @after { | ||
| 553 | leaveRule(); | ||
| 554 | }: | ||
| 555 | ( | ||
| 556 | ( | ||
| 557 | lv_name_0_0=RULE_ID | ||
| 558 | { | ||
| 559 | newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); | ||
| 560 | } | ||
| 561 | { | ||
| 562 | if ($current==null) { | ||
| 563 | $current = createModelElement(grammarAccess.getModelSymbolRule()); | ||
| 564 | } | ||
| 565 | setWithLastConsumed( | ||
| 566 | $current, | ||
| 567 | "name", | ||
| 568 | lv_name_0_0, | ||
| 569 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 570 | } | ||
| 571 | ) | ||
| 572 | ) | ||
| 573 | ; | ||
| 574 | |||
| 575 | // Entry rule entryRulePartialitySymbol | ||
| 576 | entryRulePartialitySymbol returns [EObject current=null]: | ||
| 577 | { newCompositeNode(grammarAccess.getPartialitySymbolRule()); } | ||
| 578 | iv_rulePartialitySymbol=rulePartialitySymbol | ||
| 579 | { $current=$iv_rulePartialitySymbol.current; } | ||
| 580 | EOF; | ||
| 581 | |||
| 582 | // Rule PartialitySymbol | ||
| 583 | rulePartialitySymbol returns [EObject current=null] | ||
| 584 | @init { | ||
| 585 | enterRule(); | ||
| 586 | } | ||
| 587 | @after { | ||
| 588 | leaveRule(); | ||
| 589 | }: | ||
| 590 | ( | ||
| 591 | { | ||
| 592 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); | ||
| 593 | } | ||
| 594 | this_ExistSymbol_0=ruleExistSymbol | ||
| 595 | { | ||
| 596 | $current = $this_ExistSymbol_0.current; | ||
| 597 | afterParserOrEnumRuleCall(); | ||
| 598 | } | ||
| 599 | | | ||
| 600 | { | ||
| 601 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); | ||
| 602 | } | ||
| 603 | this_EqualsSymbol_1=ruleEqualsSymbol | ||
| 604 | { | ||
| 605 | $current = $this_EqualsSymbol_1.current; | ||
| 606 | afterParserOrEnumRuleCall(); | ||
| 607 | } | ||
| 608 | ) | ||
| 609 | ; | ||
| 610 | |||
| 611 | // Entry rule entryRuleExistSymbol | ||
| 612 | entryRuleExistSymbol returns [EObject current=null]: | ||
| 613 | { newCompositeNode(grammarAccess.getExistSymbolRule()); } | ||
| 614 | iv_ruleExistSymbol=ruleExistSymbol | ||
| 615 | { $current=$iv_ruleExistSymbol.current; } | ||
| 616 | EOF; | ||
| 617 | |||
| 618 | // Rule ExistSymbol | ||
| 619 | ruleExistSymbol returns [EObject current=null] | ||
| 620 | @init { | ||
| 621 | enterRule(); | ||
| 622 | } | ||
| 623 | @after { | ||
| 624 | leaveRule(); | ||
| 625 | }: | ||
| 626 | ( | ||
| 627 | otherlv_0='exists' | ||
| 628 | { | ||
| 629 | newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); | ||
| 630 | } | ||
| 631 | ( | ||
| 632 | { | ||
| 633 | $current = forceCreateModelElement( | ||
| 634 | grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), | ||
| 635 | $current); | ||
| 636 | } | ||
| 637 | ) | ||
| 638 | ) | ||
| 639 | ; | ||
| 640 | |||
| 641 | // Entry rule entryRuleEqualsSymbol | ||
| 642 | entryRuleEqualsSymbol returns [EObject current=null]: | ||
| 643 | { newCompositeNode(grammarAccess.getEqualsSymbolRule()); } | ||
| 644 | iv_ruleEqualsSymbol=ruleEqualsSymbol | ||
| 645 | { $current=$iv_ruleEqualsSymbol.current; } | ||
| 646 | EOF; | ||
| 647 | |||
| 648 | // Rule EqualsSymbol | ||
| 649 | ruleEqualsSymbol returns [EObject current=null] | ||
| 650 | @init { | ||
| 651 | enterRule(); | ||
| 652 | } | ||
| 653 | @after { | ||
| 654 | leaveRule(); | ||
| 655 | }: | ||
| 656 | ( | ||
| 657 | otherlv_0='equals' | ||
| 658 | { | ||
| 659 | newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); | ||
| 660 | } | ||
| 661 | ( | ||
| 662 | { | ||
| 663 | $current = forceCreateModelElement( | ||
| 664 | grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), | ||
| 665 | $current); | ||
| 666 | } | ||
| 667 | ) | ||
| 668 | ) | ||
| 669 | ; | ||
| 670 | |||
| 671 | // Entry rule entryRuleDataSymbol | ||
| 672 | entryRuleDataSymbol returns [EObject current=null]: | ||
| 673 | { newCompositeNode(grammarAccess.getDataSymbolRule()); } | ||
| 674 | iv_ruleDataSymbol=ruleDataSymbol | ||
| 675 | { $current=$iv_ruleDataSymbol.current; } | ||
| 676 | EOF; | ||
| 677 | |||
| 678 | // Rule DataSymbol | ||
| 679 | ruleDataSymbol returns [EObject current=null] | ||
| 680 | @init { | ||
| 681 | enterRule(); | ||
| 682 | } | ||
| 683 | @after { | ||
| 684 | leaveRule(); | ||
| 685 | }: | ||
| 686 | ( | ||
| 687 | { | ||
| 688 | newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); | ||
| 689 | } | ||
| 690 | this_BooleanSymbol_0=ruleBooleanSymbol | ||
| 691 | { | ||
| 692 | $current = $this_BooleanSymbol_0.current; | ||
| 693 | afterParserOrEnumRuleCall(); | ||
| 694 | } | ||
| 695 | | | ||
| 696 | { | ||
| 697 | newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); | ||
| 698 | } | ||
| 699 | this_IntegerSymbol_1=ruleIntegerSymbol | ||
| 700 | { | ||
| 701 | $current = $this_IntegerSymbol_1.current; | ||
| 702 | afterParserOrEnumRuleCall(); | ||
| 703 | } | ||
| 704 | | | ||
| 705 | { | ||
| 706 | newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); | ||
| 707 | } | ||
| 708 | this_RealSymbol_2=ruleRealSymbol | ||
| 709 | { | ||
| 710 | $current = $this_RealSymbol_2.current; | ||
| 711 | afterParserOrEnumRuleCall(); | ||
| 712 | } | ||
| 713 | | | ||
| 714 | { | ||
| 715 | newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); | ||
| 716 | } | ||
| 717 | this_StringSymbol_3=ruleStringSymbol | ||
| 718 | { | ||
| 719 | $current = $this_StringSymbol_3.current; | ||
| 720 | afterParserOrEnumRuleCall(); | ||
| 721 | } | ||
| 722 | ) | ||
| 723 | ; | ||
| 724 | |||
| 725 | // Entry rule entryRuleBooleanSymbol | ||
| 726 | entryRuleBooleanSymbol returns [EObject current=null]: | ||
| 727 | { newCompositeNode(grammarAccess.getBooleanSymbolRule()); } | ||
| 728 | iv_ruleBooleanSymbol=ruleBooleanSymbol | ||
| 729 | { $current=$iv_ruleBooleanSymbol.current; } | ||
| 730 | EOF; | ||
| 731 | |||
| 732 | // Rule BooleanSymbol | ||
| 733 | ruleBooleanSymbol returns [EObject current=null] | ||
| 734 | @init { | ||
| 735 | enterRule(); | ||
| 736 | } | ||
| 737 | @after { | ||
| 738 | leaveRule(); | ||
| 739 | }: | ||
| 740 | ( | ||
| 741 | otherlv_0='bool' | ||
| 742 | { | ||
| 743 | newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); | ||
| 744 | } | ||
| 745 | ( | ||
| 746 | { | ||
| 747 | $current = forceCreateModelElement( | ||
| 748 | grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), | ||
| 749 | $current); | ||
| 750 | } | ||
| 751 | ) | ||
| 752 | ) | ||
| 753 | ; | ||
| 754 | |||
| 755 | // Entry rule entryRuleIntegerSymbol | ||
| 756 | entryRuleIntegerSymbol returns [EObject current=null]: | ||
| 757 | { newCompositeNode(grammarAccess.getIntegerSymbolRule()); } | ||
| 758 | iv_ruleIntegerSymbol=ruleIntegerSymbol | ||
| 759 | { $current=$iv_ruleIntegerSymbol.current; } | ||
| 760 | EOF; | ||
| 761 | |||
| 762 | // Rule IntegerSymbol | ||
| 763 | ruleIntegerSymbol returns [EObject current=null] | ||
| 764 | @init { | ||
| 765 | enterRule(); | ||
| 766 | } | ||
| 767 | @after { | ||
| 768 | leaveRule(); | ||
| 769 | }: | ||
| 770 | ( | ||
| 771 | otherlv_0='int' | ||
| 772 | { | ||
| 773 | newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); | ||
| 774 | } | ||
| 775 | ( | ||
| 776 | { | ||
| 777 | $current = forceCreateModelElement( | ||
| 778 | grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), | ||
| 779 | $current); | ||
| 780 | } | ||
| 781 | ) | ||
| 782 | ) | ||
| 783 | ; | ||
| 784 | |||
| 785 | // Entry rule entryRuleRealSymbol | ||
| 786 | entryRuleRealSymbol returns [EObject current=null]: | ||
| 787 | { newCompositeNode(grammarAccess.getRealSymbolRule()); } | ||
| 788 | iv_ruleRealSymbol=ruleRealSymbol | ||
| 789 | { $current=$iv_ruleRealSymbol.current; } | ||
| 790 | EOF; | ||
| 791 | |||
| 792 | // Rule RealSymbol | ||
| 793 | ruleRealSymbol returns [EObject current=null] | ||
| 794 | @init { | ||
| 795 | enterRule(); | ||
| 796 | } | ||
| 797 | @after { | ||
| 798 | leaveRule(); | ||
| 799 | }: | ||
| 800 | ( | ||
| 801 | otherlv_0='real' | ||
| 802 | { | ||
| 803 | newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); | ||
| 804 | } | ||
| 805 | ( | ||
| 806 | { | ||
| 807 | $current = forceCreateModelElement( | ||
| 808 | grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), | ||
| 809 | $current); | ||
| 810 | } | ||
| 811 | ) | ||
| 812 | ) | ||
| 813 | ; | ||
| 814 | |||
| 815 | // Entry rule entryRuleStringSymbol | ||
| 816 | entryRuleStringSymbol returns [EObject current=null]: | ||
| 817 | { newCompositeNode(grammarAccess.getStringSymbolRule()); } | ||
| 818 | iv_ruleStringSymbol=ruleStringSymbol | ||
| 819 | { $current=$iv_ruleStringSymbol.current; } | ||
| 820 | EOF; | ||
| 821 | |||
| 822 | // Rule StringSymbol | ||
| 823 | ruleStringSymbol returns [EObject current=null] | ||
| 824 | @init { | ||
| 825 | enterRule(); | ||
| 826 | } | ||
| 827 | @after { | ||
| 828 | leaveRule(); | ||
| 829 | }: | ||
| 830 | ( | ||
| 831 | otherlv_0='string' | ||
| 832 | { | ||
| 833 | newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); | ||
| 834 | } | ||
| 835 | ( | ||
| 836 | { | ||
| 837 | $current = forceCreateModelElement( | ||
| 838 | grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), | ||
| 839 | $current); | ||
| 840 | } | ||
| 841 | ) | ||
| 842 | ) | ||
| 843 | ; | ||
| 844 | |||
| 845 | // Entry rule entryRuleComplexObject | ||
| 846 | entryRuleComplexObject returns [EObject current=null]: | ||
| 847 | { newCompositeNode(grammarAccess.getComplexObjectRule()); } | ||
| 848 | iv_ruleComplexObject=ruleComplexObject | ||
| 849 | { $current=$iv_ruleComplexObject.current; } | ||
| 850 | EOF; | ||
| 851 | |||
| 852 | // Rule ComplexObject | ||
| 853 | ruleComplexObject returns [EObject current=null] | ||
| 854 | @init { | ||
| 855 | enterRule(); | ||
| 856 | } | ||
| 857 | @after { | ||
| 858 | leaveRule(); | ||
| 859 | }: | ||
| 860 | ( | ||
| 861 | { | ||
| 862 | newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); | ||
| 863 | } | ||
| 864 | this_Object_0=ruleObject | ||
| 865 | { | ||
| 866 | $current = $this_Object_0.current; | ||
| 867 | afterParserOrEnumRuleCall(); | ||
| 868 | } | ||
| 869 | | | ||
| 870 | { | ||
| 871 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); | ||
| 872 | } | ||
| 873 | this_AllInstances_1=ruleAllInstances | ||
| 874 | { | ||
| 875 | $current = $this_AllInstances_1.current; | ||
| 876 | afterParserOrEnumRuleCall(); | ||
| 877 | } | ||
| 878 | | | ||
| 879 | { | ||
| 880 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); | ||
| 881 | } | ||
| 882 | this_AllObjects_2=ruleAllObjects | ||
| 883 | { | ||
| 884 | $current = $this_AllObjects_2.current; | ||
| 885 | afterParserOrEnumRuleCall(); | ||
| 886 | } | ||
| 887 | ) | ||
| 888 | ; | ||
| 889 | |||
| 890 | // Entry rule entryRuleObject | ||
| 891 | entryRuleObject returns [EObject current=null]: | ||
| 892 | { newCompositeNode(grammarAccess.getObjectRule()); } | ||
| 893 | iv_ruleObject=ruleObject | ||
| 894 | { $current=$iv_ruleObject.current; } | ||
| 895 | EOF; | ||
| 896 | |||
| 897 | // Rule Object | ||
| 898 | ruleObject returns [EObject current=null] | ||
| 899 | @init { | ||
| 900 | enterRule(); | ||
| 901 | } | ||
| 902 | @after { | ||
| 903 | leaveRule(); | ||
| 904 | }: | ||
| 905 | ( | ||
| 906 | { | ||
| 907 | newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); | ||
| 908 | } | ||
| 909 | this_NamedObject_0=ruleNamedObject | ||
| 910 | { | ||
| 911 | $current = $this_NamedObject_0.current; | ||
| 912 | afterParserOrEnumRuleCall(); | ||
| 913 | } | ||
| 914 | | | ||
| 915 | { | ||
| 916 | newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); | ||
| 917 | } | ||
| 918 | this_UnnamedObject_1=ruleUnnamedObject | ||
| 919 | { | ||
| 920 | $current = $this_UnnamedObject_1.current; | ||
| 921 | afterParserOrEnumRuleCall(); | ||
| 922 | } | ||
| 923 | | | ||
| 924 | { | ||
| 925 | newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); | ||
| 926 | } | ||
| 927 | this_DataObject_2=ruleDataObject | ||
| 928 | { | ||
| 929 | $current = $this_DataObject_2.current; | ||
| 930 | afterParserOrEnumRuleCall(); | ||
| 931 | } | ||
| 932 | ) | ||
| 933 | ; | ||
| 934 | |||
| 935 | // Entry rule entryRuleNamedObject | ||
| 936 | entryRuleNamedObject returns [EObject current=null]: | ||
| 937 | { newCompositeNode(grammarAccess.getNamedObjectRule()); } | ||
| 938 | iv_ruleNamedObject=ruleNamedObject | ||
| 939 | { $current=$iv_ruleNamedObject.current; } | ||
| 940 | EOF; | ||
| 941 | |||
| 942 | // Rule NamedObject | ||
| 943 | ruleNamedObject returns [EObject current=null] | ||
| 944 | @init { | ||
| 945 | enterRule(); | ||
| 946 | } | ||
| 947 | @after { | ||
| 948 | leaveRule(); | ||
| 949 | }: | ||
| 950 | ( | ||
| 951 | otherlv_0='\'' | ||
| 952 | { | ||
| 953 | newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); | ||
| 954 | } | ||
| 955 | ( | ||
| 956 | ( | ||
| 957 | lv_name_1_0=RULE_ID | ||
| 958 | { | ||
| 959 | newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); | ||
| 960 | } | ||
| 961 | { | ||
| 962 | if ($current==null) { | ||
| 963 | $current = createModelElement(grammarAccess.getNamedObjectRule()); | ||
| 964 | } | ||
| 965 | setWithLastConsumed( | ||
| 966 | $current, | ||
| 967 | "name", | ||
| 968 | lv_name_1_0, | ||
| 969 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 970 | } | ||
| 971 | ) | ||
| 972 | ) | ||
| 973 | otherlv_2='\'' | ||
| 974 | { | ||
| 975 | newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); | ||
| 976 | } | ||
| 977 | ) | ||
| 978 | ; | ||
| 979 | |||
| 980 | // Entry rule entryRuleUnnamedObject | ||
| 981 | entryRuleUnnamedObject returns [EObject current=null]: | ||
| 982 | { newCompositeNode(grammarAccess.getUnnamedObjectRule()); } | ||
| 983 | iv_ruleUnnamedObject=ruleUnnamedObject | ||
| 984 | { $current=$iv_ruleUnnamedObject.current; } | ||
| 985 | EOF; | ||
| 986 | |||
| 987 | // Rule UnnamedObject | ||
| 988 | ruleUnnamedObject returns [EObject current=null] | ||
| 989 | @init { | ||
| 990 | enterRule(); | ||
| 991 | } | ||
| 992 | @after { | ||
| 993 | leaveRule(); | ||
| 994 | }: | ||
| 995 | ( | ||
| 996 | ( | ||
| 997 | lv_name_0_0=RULE_ID | ||
| 998 | { | ||
| 999 | newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); | ||
| 1000 | } | ||
| 1001 | { | ||
| 1002 | if ($current==null) { | ||
| 1003 | $current = createModelElement(grammarAccess.getUnnamedObjectRule()); | ||
| 1004 | } | ||
| 1005 | setWithLastConsumed( | ||
| 1006 | $current, | ||
| 1007 | "name", | ||
| 1008 | lv_name_0_0, | ||
| 1009 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1010 | } | ||
| 1011 | ) | ||
| 1012 | ) | ||
| 1013 | ; | ||
| 1014 | |||
| 1015 | // Entry rule entryRuleDataObject | ||
| 1016 | entryRuleDataObject returns [EObject current=null]: | ||
| 1017 | { newCompositeNode(grammarAccess.getDataObjectRule()); } | ||
| 1018 | iv_ruleDataObject=ruleDataObject | ||
| 1019 | { $current=$iv_ruleDataObject.current; } | ||
| 1020 | EOF; | ||
| 1021 | |||
| 1022 | // Rule DataObject | ||
| 1023 | ruleDataObject returns [EObject current=null] | ||
| 1024 | @init { | ||
| 1025 | enterRule(); | ||
| 1026 | } | ||
| 1027 | @after { | ||
| 1028 | leaveRule(); | ||
| 1029 | }: | ||
| 1030 | ( | ||
| 1031 | { | ||
| 1032 | newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); | ||
| 1033 | } | ||
| 1034 | this_BooleanObject_0=ruleBooleanObject | ||
| 1035 | { | ||
| 1036 | $current = $this_BooleanObject_0.current; | ||
| 1037 | afterParserOrEnumRuleCall(); | ||
| 1038 | } | ||
| 1039 | | | ||
| 1040 | { | ||
| 1041 | newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); | ||
| 1042 | } | ||
| 1043 | this_IntObject_1=ruleIntObject | ||
| 1044 | { | ||
| 1045 | $current = $this_IntObject_1.current; | ||
| 1046 | afterParserOrEnumRuleCall(); | ||
| 1047 | } | ||
| 1048 | | | ||
| 1049 | { | ||
| 1050 | newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); | ||
| 1051 | } | ||
| 1052 | this_RealObject_2=ruleRealObject | ||
| 1053 | { | ||
| 1054 | $current = $this_RealObject_2.current; | ||
| 1055 | afterParserOrEnumRuleCall(); | ||
| 1056 | } | ||
| 1057 | | | ||
| 1058 | { | ||
| 1059 | newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); | ||
| 1060 | } | ||
| 1061 | this_StringObject_3=ruleStringObject | ||
| 1062 | { | ||
| 1063 | $current = $this_StringObject_3.current; | ||
| 1064 | afterParserOrEnumRuleCall(); | ||
| 1065 | } | ||
| 1066 | ) | ||
| 1067 | ; | ||
| 1068 | |||
| 1069 | // Entry rule entryRuleBooleanObject | ||
| 1070 | entryRuleBooleanObject returns [EObject current=null]: | ||
| 1071 | { newCompositeNode(grammarAccess.getBooleanObjectRule()); } | ||
| 1072 | iv_ruleBooleanObject=ruleBooleanObject | ||
| 1073 | { $current=$iv_ruleBooleanObject.current; } | ||
| 1074 | EOF; | ||
| 1075 | |||
| 1076 | // Rule BooleanObject | ||
| 1077 | ruleBooleanObject returns [EObject current=null] | ||
| 1078 | @init { | ||
| 1079 | enterRule(); | ||
| 1080 | } | ||
| 1081 | @after { | ||
| 1082 | leaveRule(); | ||
| 1083 | }: | ||
| 1084 | ( | ||
| 1085 | ( | ||
| 1086 | { | ||
| 1087 | newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); | ||
| 1088 | } | ||
| 1089 | lv_value_0_0=ruleBooleanValue | ||
| 1090 | { | ||
| 1091 | if ($current==null) { | ||
| 1092 | $current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); | ||
| 1093 | } | ||
| 1094 | set( | ||
| 1095 | $current, | ||
| 1096 | "value", | ||
| 1097 | lv_value_0_0, | ||
| 1098 | "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | ||
| 1099 | afterParserOrEnumRuleCall(); | ||
| 1100 | } | ||
| 1101 | ) | ||
| 1102 | ) | ||
| 1103 | ; | ||
| 1104 | |||
| 1105 | // Entry rule entryRuleIntObject | ||
| 1106 | entryRuleIntObject returns [EObject current=null]: | ||
| 1107 | { newCompositeNode(grammarAccess.getIntObjectRule()); } | ||
| 1108 | iv_ruleIntObject=ruleIntObject | ||
| 1109 | { $current=$iv_ruleIntObject.current; } | ||
| 1110 | EOF; | ||
| 1111 | |||
| 1112 | // Rule IntObject | ||
| 1113 | ruleIntObject returns [EObject current=null] | ||
| 1114 | @init { | ||
| 1115 | enterRule(); | ||
| 1116 | } | ||
| 1117 | @after { | ||
| 1118 | leaveRule(); | ||
| 1119 | }: | ||
| 1120 | ( | ||
| 1121 | ( | ||
| 1122 | { | ||
| 1123 | newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); | ||
| 1124 | } | ||
| 1125 | lv_value_0_0=ruleINTLiteral | ||
| 1126 | { | ||
| 1127 | if ($current==null) { | ||
| 1128 | $current = createModelElementForParent(grammarAccess.getIntObjectRule()); | ||
| 1129 | } | ||
| 1130 | set( | ||
| 1131 | $current, | ||
| 1132 | "value", | ||
| 1133 | lv_value_0_0, | ||
| 1134 | "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | ||
| 1135 | afterParserOrEnumRuleCall(); | ||
| 1136 | } | ||
| 1137 | ) | ||
| 1138 | ) | ||
| 1139 | ; | ||
| 1140 | |||
| 1141 | // Entry rule entryRuleRealObject | ||
| 1142 | entryRuleRealObject returns [EObject current=null]: | ||
| 1143 | { newCompositeNode(grammarAccess.getRealObjectRule()); } | ||
| 1144 | iv_ruleRealObject=ruleRealObject | ||
| 1145 | { $current=$iv_ruleRealObject.current; } | ||
| 1146 | EOF; | ||
| 1147 | |||
| 1148 | // Rule RealObject | ||
| 1149 | ruleRealObject returns [EObject current=null] | ||
| 1150 | @init { | ||
| 1151 | enterRule(); | ||
| 1152 | } | ||
| 1153 | @after { | ||
| 1154 | leaveRule(); | ||
| 1155 | }: | ||
| 1156 | ( | ||
| 1157 | ( | ||
| 1158 | { | ||
| 1159 | newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); | ||
| 1160 | } | ||
| 1161 | lv_value_0_0=ruleREALLiteral | ||
| 1162 | { | ||
| 1163 | if ($current==null) { | ||
| 1164 | $current = createModelElementForParent(grammarAccess.getRealObjectRule()); | ||
| 1165 | } | ||
| 1166 | set( | ||
| 1167 | $current, | ||
| 1168 | "value", | ||
| 1169 | lv_value_0_0, | ||
| 1170 | "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | ||
| 1171 | afterParserOrEnumRuleCall(); | ||
| 1172 | } | ||
| 1173 | ) | ||
| 1174 | ) | ||
| 1175 | ; | ||
| 1176 | |||
| 1177 | // Entry rule entryRuleStringObject | ||
| 1178 | entryRuleStringObject returns [EObject current=null]: | ||
| 1179 | { newCompositeNode(grammarAccess.getStringObjectRule()); } | ||
| 1180 | iv_ruleStringObject=ruleStringObject | ||
| 1181 | { $current=$iv_ruleStringObject.current; } | ||
| 1182 | EOF; | ||
| 1183 | |||
| 1184 | // Rule StringObject | ||
| 1185 | ruleStringObject returns [EObject current=null] | ||
| 1186 | @init { | ||
| 1187 | enterRule(); | ||
| 1188 | } | ||
| 1189 | @after { | ||
| 1190 | leaveRule(); | ||
| 1191 | }: | ||
| 1192 | ( | ||
| 1193 | ( | ||
| 1194 | lv_value_0_0=RULE_STRING | ||
| 1195 | { | ||
| 1196 | newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); | ||
| 1197 | } | ||
| 1198 | { | ||
| 1199 | if ($current==null) { | ||
| 1200 | $current = createModelElement(grammarAccess.getStringObjectRule()); | ||
| 1201 | } | ||
| 1202 | setWithLastConsumed( | ||
| 1203 | $current, | ||
| 1204 | "value", | ||
| 1205 | lv_value_0_0, | ||
| 1206 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 1207 | } | ||
| 1208 | ) | ||
| 1209 | ) | ||
| 1210 | ; | ||
| 1211 | |||
| 1212 | // Entry rule entryRulePredicate | ||
| 1213 | entryRulePredicate returns [EObject current=null]: | ||
| 1214 | { newCompositeNode(grammarAccess.getPredicateRule()); } | ||
| 1215 | iv_rulePredicate=rulePredicate | ||
| 1216 | { $current=$iv_rulePredicate.current; } | ||
| 1217 | EOF; | ||
| 1218 | |||
| 1219 | // Rule Predicate | ||
| 1220 | rulePredicate returns [EObject current=null] | ||
| 1221 | @init { | ||
| 1222 | enterRule(); | ||
| 1223 | } | ||
| 1224 | @after { | ||
| 1225 | leaveRule(); | ||
| 1226 | }: | ||
| 1227 | ( | ||
| 1228 | ( | ||
| 1229 | ( | ||
| 1230 | lv_isError_0_0='error' | ||
| 1231 | { | ||
| 1232 | newLeafNode(lv_isError_0_0, grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); | ||
| 1233 | } | ||
| 1234 | { | ||
| 1235 | if ($current==null) { | ||
| 1236 | $current = createModelElement(grammarAccess.getPredicateRule()); | ||
| 1237 | } | ||
| 1238 | setWithLastConsumed($current, "isError", true, "error"); | ||
| 1239 | } | ||
| 1240 | ) | ||
| 1241 | )? | ||
| 1242 | ( | ||
| 1243 | ( | ||
| 1244 | { | ||
| 1245 | newCompositeNode(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 1246 | } | ||
| 1247 | lv_symbol_1_0=ruleModelSymbol | ||
| 1248 | { | ||
| 1249 | if ($current==null) { | ||
| 1250 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1251 | } | ||
| 1252 | set( | ||
| 1253 | $current, | ||
| 1254 | "symbol", | ||
| 1255 | lv_symbol_1_0, | ||
| 1256 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 1257 | afterParserOrEnumRuleCall(); | ||
| 1258 | } | ||
| 1259 | ) | ||
| 1260 | ) | ||
| 1261 | ( | ||
| 1262 | otherlv_2='(' | ||
| 1263 | { | ||
| 1264 | newLeafNode(otherlv_2, grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); | ||
| 1265 | } | ||
| 1266 | ( | ||
| 1267 | ( | ||
| 1268 | ( | ||
| 1269 | { | ||
| 1270 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); | ||
| 1271 | } | ||
| 1272 | lv_parameters_3_0=ruleParameter | ||
| 1273 | { | ||
| 1274 | if ($current==null) { | ||
| 1275 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1276 | } | ||
| 1277 | add( | ||
| 1278 | $current, | ||
| 1279 | "parameters", | ||
| 1280 | lv_parameters_3_0, | ||
| 1281 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1282 | afterParserOrEnumRuleCall(); | ||
| 1283 | } | ||
| 1284 | ) | ||
| 1285 | ) | ||
| 1286 | ( | ||
| 1287 | otherlv_4=',' | ||
| 1288 | { | ||
| 1289 | newLeafNode(otherlv_4, grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); | ||
| 1290 | } | ||
| 1291 | ( | ||
| 1292 | ( | ||
| 1293 | { | ||
| 1294 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); | ||
| 1295 | } | ||
| 1296 | lv_parameters_5_0=ruleParameter | ||
| 1297 | { | ||
| 1298 | if ($current==null) { | ||
| 1299 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1300 | } | ||
| 1301 | add( | ||
| 1302 | $current, | ||
| 1303 | "parameters", | ||
| 1304 | lv_parameters_5_0, | ||
| 1305 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 1306 | afterParserOrEnumRuleCall(); | ||
| 1307 | } | ||
| 1308 | ) | ||
| 1309 | ) | ||
| 1310 | )* | ||
| 1311 | )? | ||
| 1312 | otherlv_6=')' | ||
| 1313 | { | ||
| 1314 | newLeafNode(otherlv_6, grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); | ||
| 1315 | } | ||
| 1316 | )? | ||
| 1317 | otherlv_7=':-' | ||
| 1318 | { | ||
| 1319 | newLeafNode(otherlv_7, grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); | ||
| 1320 | } | ||
| 1321 | ( | ||
| 1322 | otherlv_8='false' | ||
| 1323 | { | ||
| 1324 | newLeafNode(otherlv_8, grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); | ||
| 1325 | } | ||
| 1326 | | | ||
| 1327 | ( | ||
| 1328 | ( | ||
| 1329 | ( | ||
| 1330 | { | ||
| 1331 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); | ||
| 1332 | } | ||
| 1333 | lv_bodies_9_0=rulePatternBody | ||
| 1334 | { | ||
| 1335 | if ($current==null) { | ||
| 1336 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1337 | } | ||
| 1338 | add( | ||
| 1339 | $current, | ||
| 1340 | "bodies", | ||
| 1341 | lv_bodies_9_0, | ||
| 1342 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1343 | afterParserOrEnumRuleCall(); | ||
| 1344 | } | ||
| 1345 | ) | ||
| 1346 | ) | ||
| 1347 | ( | ||
| 1348 | otherlv_10='|' | ||
| 1349 | { | ||
| 1350 | newLeafNode(otherlv_10, grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); | ||
| 1351 | } | ||
| 1352 | ( | ||
| 1353 | ( | ||
| 1354 | { | ||
| 1355 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); | ||
| 1356 | } | ||
| 1357 | lv_bodies_11_0=rulePatternBody | ||
| 1358 | { | ||
| 1359 | if ($current==null) { | ||
| 1360 | $current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 1361 | } | ||
| 1362 | add( | ||
| 1363 | $current, | ||
| 1364 | "bodies", | ||
| 1365 | lv_bodies_11_0, | ||
| 1366 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 1367 | afterParserOrEnumRuleCall(); | ||
| 1368 | } | ||
| 1369 | ) | ||
| 1370 | ) | ||
| 1371 | )* | ||
| 1372 | ) | ||
| 1373 | ) | ||
| 1374 | otherlv_12='.' | ||
| 1375 | { | ||
| 1376 | newLeafNode(otherlv_12, grammarAccess.getPredicateAccess().getFullStopKeyword_5()); | ||
| 1377 | } | ||
| 1378 | ) | ||
| 1379 | ; | ||
| 1380 | |||
| 1381 | // Entry rule entryRuleParameter | ||
| 1382 | entryRuleParameter returns [EObject current=null]: | ||
| 1383 | { newCompositeNode(grammarAccess.getParameterRule()); } | ||
| 1384 | iv_ruleParameter=ruleParameter | ||
| 1385 | { $current=$iv_ruleParameter.current; } | ||
| 1386 | EOF; | ||
| 1387 | |||
| 1388 | // Rule Parameter | ||
| 1389 | ruleParameter returns [EObject current=null] | ||
| 1390 | @init { | ||
| 1391 | enterRule(); | ||
| 1392 | } | ||
| 1393 | @after { | ||
| 1394 | leaveRule(); | ||
| 1395 | }: | ||
| 1396 | ( | ||
| 1397 | ( | ||
| 1398 | ( | ||
| 1399 | { | ||
| 1400 | newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); | ||
| 1401 | } | ||
| 1402 | lv_variable_0_0=ruleVariable | ||
| 1403 | { | ||
| 1404 | if ($current==null) { | ||
| 1405 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | ||
| 1406 | } | ||
| 1407 | set( | ||
| 1408 | $current, | ||
| 1409 | "variable", | ||
| 1410 | lv_variable_0_0, | ||
| 1411 | "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | ||
| 1412 | afterParserOrEnumRuleCall(); | ||
| 1413 | } | ||
| 1414 | ) | ||
| 1415 | ) | ||
| 1416 | ( | ||
| 1417 | otherlv_1=':' | ||
| 1418 | { | ||
| 1419 | newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); | ||
| 1420 | } | ||
| 1421 | ( | ||
| 1422 | ( | ||
| 1423 | { | ||
| 1424 | newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); | ||
| 1425 | } | ||
| 1426 | lv_type_2_0=ruleSymbol | ||
| 1427 | { | ||
| 1428 | if ($current==null) { | ||
| 1429 | $current = createModelElementForParent(grammarAccess.getParameterRule()); | ||
| 1430 | } | ||
| 1431 | set( | ||
| 1432 | $current, | ||
| 1433 | "type", | ||
| 1434 | lv_type_2_0, | ||
| 1435 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 1436 | afterParserOrEnumRuleCall(); | ||
| 1437 | } | ||
| 1438 | ) | ||
| 1439 | ) | ||
| 1440 | )? | ||
| 1441 | ) | ||
| 1442 | ; | ||
| 1443 | |||
| 1444 | // Entry rule entryRulePatternBody | ||
| 1445 | entryRulePatternBody returns [EObject current=null]: | ||
| 1446 | { newCompositeNode(grammarAccess.getPatternBodyRule()); } | ||
| 1447 | iv_rulePatternBody=rulePatternBody | ||
| 1448 | { $current=$iv_rulePatternBody.current; } | ||
| 1449 | EOF; | ||
| 1450 | |||
| 1451 | // Rule PatternBody | ||
| 1452 | rulePatternBody returns [EObject current=null] | ||
| 1453 | @init { | ||
| 1454 | enterRule(); | ||
| 1455 | } | ||
| 1456 | @after { | ||
| 1457 | leaveRule(); | ||
| 1458 | }: | ||
| 1459 | ( | ||
| 1460 | ( | ||
| 1461 | { | ||
| 1462 | $current = forceCreateModelElement( | ||
| 1463 | grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), | ||
| 1464 | $current); | ||
| 1465 | } | ||
| 1466 | ) | ||
| 1467 | ( | ||
| 1468 | otherlv_1='true' | ||
| 1469 | { | ||
| 1470 | newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | ||
| 1471 | } | ||
| 1472 | | | ||
| 1473 | ( | ||
| 1474 | ( | ||
| 1475 | { | ||
| 1476 | newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); | ||
| 1477 | } | ||
| 1478 | lv_constraints_2_0=ruleConstraint | ||
| 1479 | { | ||
| 1480 | if ($current==null) { | ||
| 1481 | $current = createModelElementForParent(grammarAccess.getPatternBodyRule()); | ||
| 1482 | } | ||
| 1483 | add( | ||
| 1484 | $current, | ||
| 1485 | "constraints", | ||
| 1486 | lv_constraints_2_0, | ||
| 1487 | "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | ||
| 1488 | afterParserOrEnumRuleCall(); | ||
| 1489 | } | ||
| 1490 | ) | ||
| 1491 | )* | ||
| 1492 | ) | ||
| 1493 | ) | ||
| 1494 | ; | ||
| 1495 | |||
| 1496 | // Entry rule entryRulePolarity | ||
| 1497 | entryRulePolarity returns [EObject current=null]: | ||
| 1498 | { newCompositeNode(grammarAccess.getPolarityRule()); } | ||
| 1499 | iv_rulePolarity=rulePolarity | ||
| 1500 | { $current=$iv_rulePolarity.current; } | ||
| 1501 | EOF; | ||
| 1502 | |||
| 1503 | // Rule Polarity | ||
| 1504 | rulePolarity returns [EObject current=null] | ||
| 1505 | @init { | ||
| 1506 | enterRule(); | ||
| 1507 | } | ||
| 1508 | @after { | ||
| 1509 | leaveRule(); | ||
| 1510 | }: | ||
| 1511 | ( | ||
| 1512 | ( | ||
| 1513 | ( | ||
| 1514 | { | ||
| 1515 | $current = forceCreateModelElement( | ||
| 1516 | grammarAccess.getPolarityAccess().getPositiveAction_0_0(), | ||
| 1517 | $current); | ||
| 1518 | } | ||
| 1519 | ) | ||
| 1520 | otherlv_1='+' | ||
| 1521 | { | ||
| 1522 | newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); | ||
| 1523 | } | ||
| 1524 | ) | ||
| 1525 | | | ||
| 1526 | ( | ||
| 1527 | ( | ||
| 1528 | { | ||
| 1529 | $current = forceCreateModelElement( | ||
| 1530 | grammarAccess.getPolarityAccess().getNegativeAction_1_0(), | ||
| 1531 | $current); | ||
| 1532 | } | ||
| 1533 | ) | ||
| 1534 | otherlv_3='-' | ||
| 1535 | { | ||
| 1536 | newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); | ||
| 1537 | } | ||
| 1538 | ) | ||
| 1539 | ) | ||
| 1540 | ; | ||
| 1541 | |||
| 1542 | // Entry rule entryRuleConstraint | ||
| 1543 | entryRuleConstraint returns [EObject current=null]: | ||
| 1544 | { newCompositeNode(grammarAccess.getConstraintRule()); } | ||
| 1545 | iv_ruleConstraint=ruleConstraint | ||
| 1546 | { $current=$iv_ruleConstraint.current; } | ||
| 1547 | EOF; | ||
| 1548 | |||
| 1549 | // Rule Constraint | ||
| 1550 | ruleConstraint returns [EObject current=null] | ||
| 1551 | @init { | ||
| 1552 | enterRule(); | ||
| 1553 | } | ||
| 1554 | @after { | ||
| 1555 | leaveRule(); | ||
| 1556 | }: | ||
| 1557 | ( | ||
| 1558 | ( | ||
| 1559 | ( | ||
| 1560 | ( | ||
| 1561 | { | ||
| 1562 | newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); | ||
| 1563 | } | ||
| 1564 | lv_polarity_0_0=rulePolarity | ||
| 1565 | { | ||
| 1566 | if ($current==null) { | ||
| 1567 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1568 | } | ||
| 1569 | set( | ||
| 1570 | $current, | ||
| 1571 | "polarity", | ||
| 1572 | lv_polarity_0_0, | ||
| 1573 | "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | ||
| 1574 | afterParserOrEnumRuleCall(); | ||
| 1575 | } | ||
| 1576 | ) | ||
| 1577 | )? | ||
| 1578 | ( | ||
| 1579 | ( | ||
| 1580 | { | ||
| 1581 | newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); | ||
| 1582 | } | ||
| 1583 | lv_symbol_1_0=ruleModelSymbol | ||
| 1584 | { | ||
| 1585 | if ($current==null) { | ||
| 1586 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1587 | } | ||
| 1588 | set( | ||
| 1589 | $current, | ||
| 1590 | "symbol", | ||
| 1591 | lv_symbol_1_0, | ||
| 1592 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 1593 | afterParserOrEnumRuleCall(); | ||
| 1594 | } | ||
| 1595 | ) | ||
| 1596 | ) | ||
| 1597 | ( | ||
| 1598 | otherlv_2='(' | ||
| 1599 | { | ||
| 1600 | newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); | ||
| 1601 | } | ||
| 1602 | ( | ||
| 1603 | ( | ||
| 1604 | { | ||
| 1605 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); | ||
| 1606 | } | ||
| 1607 | lv_params_3_0=ruleLiteral | ||
| 1608 | { | ||
| 1609 | if ($current==null) { | ||
| 1610 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1611 | } | ||
| 1612 | add( | ||
| 1613 | $current, | ||
| 1614 | "params", | ||
| 1615 | lv_params_3_0, | ||
| 1616 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1617 | afterParserOrEnumRuleCall(); | ||
| 1618 | } | ||
| 1619 | ) | ||
| 1620 | )? | ||
| 1621 | ( | ||
| 1622 | otherlv_4=',' | ||
| 1623 | { | ||
| 1624 | newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); | ||
| 1625 | } | ||
| 1626 | ( | ||
| 1627 | ( | ||
| 1628 | { | ||
| 1629 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); | ||
| 1630 | } | ||
| 1631 | lv_params_5_0=ruleLiteral | ||
| 1632 | { | ||
| 1633 | if ($current==null) { | ||
| 1634 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1635 | } | ||
| 1636 | add( | ||
| 1637 | $current, | ||
| 1638 | "params", | ||
| 1639 | lv_params_5_0, | ||
| 1640 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1641 | afterParserOrEnumRuleCall(); | ||
| 1642 | } | ||
| 1643 | ) | ||
| 1644 | ) | ||
| 1645 | )* | ||
| 1646 | otherlv_6=')' | ||
| 1647 | { | ||
| 1648 | newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); | ||
| 1649 | } | ||
| 1650 | )? | ||
| 1651 | ) | ||
| 1652 | | | ||
| 1653 | ( | ||
| 1654 | ( | ||
| 1655 | ( | ||
| 1656 | { | ||
| 1657 | newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); | ||
| 1658 | } | ||
| 1659 | lv_closureType_7_0=ruleClosureType | ||
| 1660 | { | ||
| 1661 | if ($current==null) { | ||
| 1662 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1663 | } | ||
| 1664 | set( | ||
| 1665 | $current, | ||
| 1666 | "closureType", | ||
| 1667 | lv_closureType_7_0, | ||
| 1668 | "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | ||
| 1669 | afterParserOrEnumRuleCall(); | ||
| 1670 | } | ||
| 1671 | ) | ||
| 1672 | ) | ||
| 1673 | otherlv_8='(' | ||
| 1674 | { | ||
| 1675 | newLeafNode(otherlv_8, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); | ||
| 1676 | } | ||
| 1677 | ( | ||
| 1678 | ( | ||
| 1679 | { | ||
| 1680 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); | ||
| 1681 | } | ||
| 1682 | lv_params_9_0=ruleLiteral | ||
| 1683 | { | ||
| 1684 | if ($current==null) { | ||
| 1685 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1686 | } | ||
| 1687 | add( | ||
| 1688 | $current, | ||
| 1689 | "params", | ||
| 1690 | lv_params_9_0, | ||
| 1691 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1692 | afterParserOrEnumRuleCall(); | ||
| 1693 | } | ||
| 1694 | ) | ||
| 1695 | )? | ||
| 1696 | ( | ||
| 1697 | otherlv_10=',' | ||
| 1698 | { | ||
| 1699 | newLeafNode(otherlv_10, grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); | ||
| 1700 | } | ||
| 1701 | ( | ||
| 1702 | ( | ||
| 1703 | { | ||
| 1704 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); | ||
| 1705 | } | ||
| 1706 | lv_params_11_0=ruleLiteral | ||
| 1707 | { | ||
| 1708 | if ($current==null) { | ||
| 1709 | $current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 1710 | } | ||
| 1711 | add( | ||
| 1712 | $current, | ||
| 1713 | "params", | ||
| 1714 | lv_params_11_0, | ||
| 1715 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1716 | afterParserOrEnumRuleCall(); | ||
| 1717 | } | ||
| 1718 | ) | ||
| 1719 | ) | ||
| 1720 | )* | ||
| 1721 | otherlv_12=')' | ||
| 1722 | { | ||
| 1723 | newLeafNode(otherlv_12, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); | ||
| 1724 | } | ||
| 1725 | ) | ||
| 1726 | ) | ||
| 1727 | ; | ||
| 1728 | |||
| 1729 | // Entry rule entryRuleClosureType | ||
| 1730 | entryRuleClosureType returns [EObject current=null]: | ||
| 1731 | { newCompositeNode(grammarAccess.getClosureTypeRule()); } | ||
| 1732 | iv_ruleClosureType=ruleClosureType | ||
| 1733 | { $current=$iv_ruleClosureType.current; } | ||
| 1734 | EOF; | ||
| 1735 | |||
| 1736 | // Rule ClosureType | ||
| 1737 | ruleClosureType returns [EObject current=null] | ||
| 1738 | @init { | ||
| 1739 | enterRule(); | ||
| 1740 | } | ||
| 1741 | @after { | ||
| 1742 | leaveRule(); | ||
| 1743 | }: | ||
| 1744 | ( | ||
| 1745 | ( | ||
| 1746 | ( | ||
| 1747 | { | ||
| 1748 | $current = forceCreateModelElement( | ||
| 1749 | grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), | ||
| 1750 | $current); | ||
| 1751 | } | ||
| 1752 | ) | ||
| 1753 | otherlv_1='*' | ||
| 1754 | { | ||
| 1755 | newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); | ||
| 1756 | } | ||
| 1757 | ) | ||
| 1758 | | | ||
| 1759 | ( | ||
| 1760 | ( | ||
| 1761 | { | ||
| 1762 | $current = forceCreateModelElement( | ||
| 1763 | grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), | ||
| 1764 | $current); | ||
| 1765 | } | ||
| 1766 | ) | ||
| 1767 | otherlv_3='+' | ||
| 1768 | { | ||
| 1769 | newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); | ||
| 1770 | } | ||
| 1771 | ) | ||
| 1772 | ) | ||
| 1773 | ; | ||
| 1774 | |||
| 1775 | // Entry rule entryRuleLiteral | ||
| 1776 | entryRuleLiteral returns [EObject current=null]: | ||
| 1777 | { newCompositeNode(grammarAccess.getLiteralRule()); } | ||
| 1778 | iv_ruleLiteral=ruleLiteral | ||
| 1779 | { $current=$iv_ruleLiteral.current; } | ||
| 1780 | EOF; | ||
| 1781 | |||
| 1782 | // Rule Literal | ||
| 1783 | ruleLiteral returns [EObject current=null] | ||
| 1784 | @init { | ||
| 1785 | enterRule(); | ||
| 1786 | } | ||
| 1787 | @after { | ||
| 1788 | leaveRule(); | ||
| 1789 | }: | ||
| 1790 | ( | ||
| 1791 | { | ||
| 1792 | newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); | ||
| 1793 | } | ||
| 1794 | this_Variable_0=ruleVariable | ||
| 1795 | { | ||
| 1796 | $current = $this_Variable_0.current; | ||
| 1797 | afterParserOrEnumRuleCall(); | ||
| 1798 | } | ||
| 1799 | | | ||
| 1800 | { | ||
| 1801 | newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); | ||
| 1802 | } | ||
| 1803 | this_DataObject_1=ruleDataObject | ||
| 1804 | { | ||
| 1805 | $current = $this_DataObject_1.current; | ||
| 1806 | afterParserOrEnumRuleCall(); | ||
| 1807 | } | ||
| 1808 | | | ||
| 1809 | { | ||
| 1810 | newCompositeNode(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); | ||
| 1811 | } | ||
| 1812 | this_NamedObject_2=ruleNamedObject | ||
| 1813 | { | ||
| 1814 | $current = $this_NamedObject_2.current; | ||
| 1815 | afterParserOrEnumRuleCall(); | ||
| 1816 | } | ||
| 1817 | ) | ||
| 1818 | ; | ||
| 1819 | |||
| 1820 | // Entry rule entryRuleVariable | ||
| 1821 | entryRuleVariable returns [EObject current=null]: | ||
| 1822 | { newCompositeNode(grammarAccess.getVariableRule()); } | ||
| 1823 | iv_ruleVariable=ruleVariable | ||
| 1824 | { $current=$iv_ruleVariable.current; } | ||
| 1825 | EOF; | ||
| 1826 | |||
| 1827 | // Rule Variable | ||
| 1828 | ruleVariable returns [EObject current=null] | ||
| 1829 | @init { | ||
| 1830 | enterRule(); | ||
| 1831 | } | ||
| 1832 | @after { | ||
| 1833 | leaveRule(); | ||
| 1834 | }: | ||
| 1835 | ( | ||
| 1836 | ( | ||
| 1837 | lv_name_0_0=RULE_ID | ||
| 1838 | { | ||
| 1839 | newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); | ||
| 1840 | } | ||
| 1841 | { | ||
| 1842 | if ($current==null) { | ||
| 1843 | $current = createModelElement(grammarAccess.getVariableRule()); | ||
| 1844 | } | ||
| 1845 | setWithLastConsumed( | ||
| 1846 | $current, | ||
| 1847 | "name", | ||
| 1848 | lv_name_0_0, | ||
| 1849 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1850 | } | ||
| 1851 | ) | ||
| 1852 | ) | ||
| 1853 | ; | ||
| 1854 | |||
| 1855 | // Entry rule entryRuleAllInstances | ||
| 1856 | entryRuleAllInstances returns [EObject current=null]: | ||
| 1857 | { newCompositeNode(grammarAccess.getAllInstancesRule()); } | ||
| 1858 | iv_ruleAllInstances=ruleAllInstances | ||
| 1859 | { $current=$iv_ruleAllInstances.current; } | ||
| 1860 | EOF; | ||
| 1861 | |||
| 1862 | // Rule AllInstances | ||
| 1863 | ruleAllInstances returns [EObject current=null] | ||
| 1864 | @init { | ||
| 1865 | enterRule(); | ||
| 1866 | } | ||
| 1867 | @after { | ||
| 1868 | leaveRule(); | ||
| 1869 | }: | ||
| 1870 | ( | ||
| 1871 | otherlv_0=':' | ||
| 1872 | { | ||
| 1873 | newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); | ||
| 1874 | } | ||
| 1875 | ( | ||
| 1876 | ( | ||
| 1877 | { | ||
| 1878 | newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); | ||
| 1879 | } | ||
| 1880 | lv_symbol_1_0=ruleSymbol | ||
| 1881 | { | ||
| 1882 | if ($current==null) { | ||
| 1883 | $current = createModelElementForParent(grammarAccess.getAllInstancesRule()); | ||
| 1884 | } | ||
| 1885 | set( | ||
| 1886 | $current, | ||
| 1887 | "symbol", | ||
| 1888 | lv_symbol_1_0, | ||
| 1889 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 1890 | afterParserOrEnumRuleCall(); | ||
| 1891 | } | ||
| 1892 | ) | ||
| 1893 | ) | ||
| 1894 | ) | ||
| 1895 | ; | ||
| 1896 | |||
| 1897 | // Entry rule entryRuleAllObjects | ||
| 1898 | entryRuleAllObjects returns [EObject current=null]: | ||
| 1899 | { newCompositeNode(grammarAccess.getAllObjectsRule()); } | ||
| 1900 | iv_ruleAllObjects=ruleAllObjects | ||
| 1901 | { $current=$iv_ruleAllObjects.current; } | ||
| 1902 | EOF; | ||
| 1903 | |||
| 1904 | // Rule AllObjects | ||
| 1905 | ruleAllObjects returns [EObject current=null] | ||
| 1906 | @init { | ||
| 1907 | enterRule(); | ||
| 1908 | } | ||
| 1909 | @after { | ||
| 1910 | leaveRule(); | ||
| 1911 | }: | ||
| 1912 | ( | ||
| 1913 | ( | ||
| 1914 | { | ||
| 1915 | $current = forceCreateModelElement( | ||
| 1916 | grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), | ||
| 1917 | $current); | ||
| 1918 | } | ||
| 1919 | ) | ||
| 1920 | otherlv_1='*' | ||
| 1921 | { | ||
| 1922 | newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); | ||
| 1923 | } | ||
| 1924 | ) | ||
| 1925 | ; | ||
| 1926 | |||
| 1927 | // Entry rule entryRuleDefaultInterpretation | ||
| 1928 | entryRuleDefaultInterpretation returns [EObject current=null]: | ||
| 1929 | { newCompositeNode(grammarAccess.getDefaultInterpretationRule()); } | ||
| 1930 | iv_ruleDefaultInterpretation=ruleDefaultInterpretation | ||
| 1931 | { $current=$iv_ruleDefaultInterpretation.current; } | ||
| 1932 | EOF; | ||
| 1933 | |||
| 1934 | // Rule DefaultInterpretation | ||
| 1935 | ruleDefaultInterpretation returns [EObject current=null] | ||
| 1936 | @init { | ||
| 1937 | enterRule(); | ||
| 1938 | } | ||
| 1939 | @after { | ||
| 1940 | leaveRule(); | ||
| 1941 | }: | ||
| 1942 | ( | ||
| 1943 | otherlv_0='default' | ||
| 1944 | { | ||
| 1945 | newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); | ||
| 1946 | } | ||
| 1947 | ( | ||
| 1948 | ( | ||
| 1949 | { | ||
| 1950 | newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); | ||
| 1951 | } | ||
| 1952 | lv_interpretation_1_0=ruleBasicInterpretation | ||
| 1953 | { | ||
| 1954 | if ($current==null) { | ||
| 1955 | $current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); | ||
| 1956 | } | ||
| 1957 | set( | ||
| 1958 | $current, | ||
| 1959 | "interpretation", | ||
| 1960 | lv_interpretation_1_0, | ||
| 1961 | "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | ||
| 1962 | afterParserOrEnumRuleCall(); | ||
| 1963 | } | ||
| 1964 | ) | ||
| 1965 | ) | ||
| 1966 | ) | ||
| 1967 | ; | ||
| 1968 | |||
| 1969 | // Entry rule entryRuleCDInterpretation | ||
| 1970 | entryRuleCDInterpretation returns [EObject current=null]: | ||
| 1971 | { newCompositeNode(grammarAccess.getCDInterpretationRule()); } | ||
| 1972 | iv_ruleCDInterpretation=ruleCDInterpretation | ||
| 1973 | { $current=$iv_ruleCDInterpretation.current; } | ||
| 1974 | EOF; | ||
| 1975 | |||
| 1976 | // Rule CDInterpretation | ||
| 1977 | ruleCDInterpretation returns [EObject current=null] | ||
| 1978 | @init { | ||
| 1979 | enterRule(); | ||
| 1980 | } | ||
| 1981 | @after { | ||
| 1982 | leaveRule(); | ||
| 1983 | }: | ||
| 1984 | ( | ||
| 1985 | { | ||
| 1986 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); | ||
| 1987 | } | ||
| 1988 | this_ClassInterpretation_0=ruleClassInterpretation | ||
| 1989 | { | ||
| 1990 | $current = $this_ClassInterpretation_0.current; | ||
| 1991 | afterParserOrEnumRuleCall(); | ||
| 1992 | } | ||
| 1993 | | | ||
| 1994 | { | ||
| 1995 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); | ||
| 1996 | } | ||
| 1997 | this_EnumInterpretation_1=ruleEnumInterpretation | ||
| 1998 | { | ||
| 1999 | $current = $this_EnumInterpretation_1.current; | ||
| 2000 | afterParserOrEnumRuleCall(); | ||
| 2001 | } | ||
| 2002 | | | ||
| 2003 | { | ||
| 2004 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); | ||
| 2005 | } | ||
| 2006 | this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation | ||
| 2007 | { | ||
| 2008 | $current = $this_GlobalRelationInterpretation_2.current; | ||
| 2009 | afterParserOrEnumRuleCall(); | ||
| 2010 | } | ||
| 2011 | ) | ||
| 2012 | ; | ||
| 2013 | |||
| 2014 | // Entry rule entryRuleClassInterpretation | ||
| 2015 | entryRuleClassInterpretation returns [EObject current=null]: | ||
| 2016 | { newCompositeNode(grammarAccess.getClassInterpretationRule()); } | ||
| 2017 | iv_ruleClassInterpretation=ruleClassInterpretation | ||
| 2018 | { $current=$iv_ruleClassInterpretation.current; } | ||
| 2019 | EOF; | ||
| 2020 | |||
| 2021 | // Rule ClassInterpretation | ||
| 2022 | ruleClassInterpretation returns [EObject current=null] | ||
| 2023 | @init { | ||
| 2024 | enterRule(); | ||
| 2025 | } | ||
| 2026 | @after { | ||
| 2027 | leaveRule(); | ||
| 2028 | }: | ||
| 2029 | ( | ||
| 2030 | ( | ||
| 2031 | ( | ||
| 2032 | lv_abstract_0_0='abstract' | ||
| 2033 | { | ||
| 2034 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); | ||
| 2035 | } | ||
| 2036 | { | ||
| 2037 | if ($current==null) { | ||
| 2038 | $current = createModelElement(grammarAccess.getClassInterpretationRule()); | ||
| 2039 | } | ||
| 2040 | setWithLastConsumed($current, "abstract", true, "abstract"); | ||
| 2041 | } | ||
| 2042 | ) | ||
| 2043 | )? | ||
| 2044 | otherlv_1='class' | ||
| 2045 | { | ||
| 2046 | newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); | ||
| 2047 | } | ||
| 2048 | ( | ||
| 2049 | ( | ||
| 2050 | { | ||
| 2051 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 2052 | } | ||
| 2053 | lv_symbol_2_0=ruleModelSymbol | ||
| 2054 | { | ||
| 2055 | if ($current==null) { | ||
| 2056 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2057 | } | ||
| 2058 | set( | ||
| 2059 | $current, | ||
| 2060 | "symbol", | ||
| 2061 | lv_symbol_2_0, | ||
| 2062 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2063 | afterParserOrEnumRuleCall(); | ||
| 2064 | } | ||
| 2065 | ) | ||
| 2066 | ) | ||
| 2067 | ( | ||
| 2068 | otherlv_3='extends' | ||
| 2069 | { | ||
| 2070 | newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); | ||
| 2071 | } | ||
| 2072 | ( | ||
| 2073 | ( | ||
| 2074 | { | ||
| 2075 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); | ||
| 2076 | } | ||
| 2077 | lv_supertypes_4_0=ruleModelSymbol | ||
| 2078 | { | ||
| 2079 | if ($current==null) { | ||
| 2080 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2081 | } | ||
| 2082 | add( | ||
| 2083 | $current, | ||
| 2084 | "supertypes", | ||
| 2085 | lv_supertypes_4_0, | ||
| 2086 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2087 | afterParserOrEnumRuleCall(); | ||
| 2088 | } | ||
| 2089 | ) | ||
| 2090 | )+ | ||
| 2091 | )? | ||
| 2092 | otherlv_5='{' | ||
| 2093 | { | ||
| 2094 | newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); | ||
| 2095 | } | ||
| 2096 | ( | ||
| 2097 | ( | ||
| 2098 | { | ||
| 2099 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); | ||
| 2100 | } | ||
| 2101 | lv_fielt_6_0=ruleFieldRelationInterpretation | ||
| 2102 | { | ||
| 2103 | if ($current==null) { | ||
| 2104 | $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 2105 | } | ||
| 2106 | add( | ||
| 2107 | $current, | ||
| 2108 | "fielt", | ||
| 2109 | lv_fielt_6_0, | ||
| 2110 | "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | ||
| 2111 | afterParserOrEnumRuleCall(); | ||
| 2112 | } | ||
| 2113 | ) | ||
| 2114 | )* | ||
| 2115 | otherlv_7='}' | ||
| 2116 | { | ||
| 2117 | newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); | ||
| 2118 | } | ||
| 2119 | ) | ||
| 2120 | ; | ||
| 2121 | |||
| 2122 | // Entry rule entryRuleEnumInterpretation | ||
| 2123 | entryRuleEnumInterpretation returns [EObject current=null]: | ||
| 2124 | { newCompositeNode(grammarAccess.getEnumInterpretationRule()); } | ||
| 2125 | iv_ruleEnumInterpretation=ruleEnumInterpretation | ||
| 2126 | { $current=$iv_ruleEnumInterpretation.current; } | ||
| 2127 | EOF; | ||
| 2128 | |||
| 2129 | // Rule EnumInterpretation | ||
| 2130 | ruleEnumInterpretation returns [EObject current=null] | ||
| 2131 | @init { | ||
| 2132 | enterRule(); | ||
| 2133 | } | ||
| 2134 | @after { | ||
| 2135 | leaveRule(); | ||
| 2136 | }: | ||
| 2137 | ( | ||
| 2138 | otherlv_0='enum' | ||
| 2139 | { | ||
| 2140 | newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); | ||
| 2141 | } | ||
| 2142 | ( | ||
| 2143 | ( | ||
| 2144 | { | ||
| 2145 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 2146 | } | ||
| 2147 | lv_Symbol_1_0=ruleModelSymbol | ||
| 2148 | { | ||
| 2149 | if ($current==null) { | ||
| 2150 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2151 | } | ||
| 2152 | set( | ||
| 2153 | $current, | ||
| 2154 | "Symbol", | ||
| 2155 | lv_Symbol_1_0, | ||
| 2156 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2157 | afterParserOrEnumRuleCall(); | ||
| 2158 | } | ||
| 2159 | ) | ||
| 2160 | ) | ||
| 2161 | otherlv_2='{' | ||
| 2162 | { | ||
| 2163 | newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); | ||
| 2164 | } | ||
| 2165 | ( | ||
| 2166 | ( | ||
| 2167 | { | ||
| 2168 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); | ||
| 2169 | } | ||
| 2170 | lv_objects_3_0=ruleNamedObject | ||
| 2171 | { | ||
| 2172 | if ($current==null) { | ||
| 2173 | $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 2174 | } | ||
| 2175 | add( | ||
| 2176 | $current, | ||
| 2177 | "objects", | ||
| 2178 | lv_objects_3_0, | ||
| 2179 | "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | ||
| 2180 | afterParserOrEnumRuleCall(); | ||
| 2181 | } | ||
| 2182 | ) | ||
| 2183 | )+ | ||
| 2184 | otherlv_4='}' | ||
| 2185 | { | ||
| 2186 | newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); | ||
| 2187 | } | ||
| 2188 | ) | ||
| 2189 | ; | ||
| 2190 | |||
| 2191 | // Entry rule entryRuleFieldRelationInterpretation | ||
| 2192 | entryRuleFieldRelationInterpretation returns [EObject current=null]: | ||
| 2193 | { newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); } | ||
| 2194 | iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation | ||
| 2195 | { $current=$iv_ruleFieldRelationInterpretation.current; } | ||
| 2196 | EOF; | ||
| 2197 | |||
| 2198 | // Rule FieldRelationInterpretation | ||
| 2199 | ruleFieldRelationInterpretation returns [EObject current=null] | ||
| 2200 | @init { | ||
| 2201 | enterRule(); | ||
| 2202 | } | ||
| 2203 | @after { | ||
| 2204 | leaveRule(); | ||
| 2205 | }: | ||
| 2206 | ( | ||
| 2207 | ( | ||
| 2208 | ( | ||
| 2209 | lv_containment_0_0='containment' | ||
| 2210 | { | ||
| 2211 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | ||
| 2212 | } | ||
| 2213 | { | ||
| 2214 | if ($current==null) { | ||
| 2215 | $current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2216 | } | ||
| 2217 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2218 | } | ||
| 2219 | ) | ||
| 2220 | )? | ||
| 2221 | ( | ||
| 2222 | ( | ||
| 2223 | { | ||
| 2224 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | ||
| 2225 | } | ||
| 2226 | lv_symbol_1_0=ruleModelSymbol | ||
| 2227 | { | ||
| 2228 | if ($current==null) { | ||
| 2229 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2230 | } | ||
| 2231 | set( | ||
| 2232 | $current, | ||
| 2233 | "symbol", | ||
| 2234 | lv_symbol_1_0, | ||
| 2235 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2236 | afterParserOrEnumRuleCall(); | ||
| 2237 | } | ||
| 2238 | ) | ||
| 2239 | ) | ||
| 2240 | otherlv_2=':' | ||
| 2241 | { | ||
| 2242 | newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); | ||
| 2243 | } | ||
| 2244 | ( | ||
| 2245 | ( | ||
| 2246 | { | ||
| 2247 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); | ||
| 2248 | } | ||
| 2249 | lv_multiplicity_3_0=ruleMultiplicityDefinition | ||
| 2250 | { | ||
| 2251 | if ($current==null) { | ||
| 2252 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2253 | } | ||
| 2254 | set( | ||
| 2255 | $current, | ||
| 2256 | "multiplicity", | ||
| 2257 | lv_multiplicity_3_0, | ||
| 2258 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2259 | afterParserOrEnumRuleCall(); | ||
| 2260 | } | ||
| 2261 | ) | ||
| 2262 | )? | ||
| 2263 | ( | ||
| 2264 | ( | ||
| 2265 | { | ||
| 2266 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); | ||
| 2267 | } | ||
| 2268 | lv_target_4_0=ruleSymbol | ||
| 2269 | { | ||
| 2270 | if ($current==null) { | ||
| 2271 | $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 2272 | } | ||
| 2273 | set( | ||
| 2274 | $current, | ||
| 2275 | "target", | ||
| 2276 | lv_target_4_0, | ||
| 2277 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2278 | afterParserOrEnumRuleCall(); | ||
| 2279 | } | ||
| 2280 | ) | ||
| 2281 | ) | ||
| 2282 | ) | ||
| 2283 | ; | ||
| 2284 | |||
| 2285 | // Entry rule entryRuleGlobalRelationInterpretation | ||
| 2286 | entryRuleGlobalRelationInterpretation returns [EObject current=null]: | ||
| 2287 | { newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); } | ||
| 2288 | iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation | ||
| 2289 | { $current=$iv_ruleGlobalRelationInterpretation.current; } | ||
| 2290 | EOF; | ||
| 2291 | |||
| 2292 | // Rule GlobalRelationInterpretation | ||
| 2293 | ruleGlobalRelationInterpretation returns [EObject current=null] | ||
| 2294 | @init { | ||
| 2295 | enterRule(); | ||
| 2296 | } | ||
| 2297 | @after { | ||
| 2298 | leaveRule(); | ||
| 2299 | }: | ||
| 2300 | ( | ||
| 2301 | ( | ||
| 2302 | ( | ||
| 2303 | lv_containment_0_0='containment' | ||
| 2304 | { | ||
| 2305 | newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | ||
| 2306 | } | ||
| 2307 | { | ||
| 2308 | if ($current==null) { | ||
| 2309 | $current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2310 | } | ||
| 2311 | setWithLastConsumed($current, "containment", true, "containment"); | ||
| 2312 | } | ||
| 2313 | ) | ||
| 2314 | )? | ||
| 2315 | otherlv_1='relation' | ||
| 2316 | { | ||
| 2317 | newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); | ||
| 2318 | } | ||
| 2319 | ( | ||
| 2320 | ( | ||
| 2321 | { | ||
| 2322 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 2323 | } | ||
| 2324 | lv_symbol_2_0=ruleModelSymbol | ||
| 2325 | { | ||
| 2326 | if ($current==null) { | ||
| 2327 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2328 | } | ||
| 2329 | set( | ||
| 2330 | $current, | ||
| 2331 | "symbol", | ||
| 2332 | lv_symbol_2_0, | ||
| 2333 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 2334 | afterParserOrEnumRuleCall(); | ||
| 2335 | } | ||
| 2336 | ) | ||
| 2337 | ) | ||
| 2338 | otherlv_3=':' | ||
| 2339 | { | ||
| 2340 | newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); | ||
| 2341 | } | ||
| 2342 | ( | ||
| 2343 | ( | ||
| 2344 | { | ||
| 2345 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); | ||
| 2346 | } | ||
| 2347 | lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition | ||
| 2348 | { | ||
| 2349 | if ($current==null) { | ||
| 2350 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2351 | } | ||
| 2352 | set( | ||
| 2353 | $current, | ||
| 2354 | "sourceMultiplicity", | ||
| 2355 | lv_sourceMultiplicity_4_0, | ||
| 2356 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2357 | afterParserOrEnumRuleCall(); | ||
| 2358 | } | ||
| 2359 | ) | ||
| 2360 | )? | ||
| 2361 | ( | ||
| 2362 | ( | ||
| 2363 | { | ||
| 2364 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); | ||
| 2365 | } | ||
| 2366 | lv_source_5_0=ruleSymbol | ||
| 2367 | { | ||
| 2368 | if ($current==null) { | ||
| 2369 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2370 | } | ||
| 2371 | set( | ||
| 2372 | $current, | ||
| 2373 | "source", | ||
| 2374 | lv_source_5_0, | ||
| 2375 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2376 | afterParserOrEnumRuleCall(); | ||
| 2377 | } | ||
| 2378 | ) | ||
| 2379 | ) | ||
| 2380 | ( | ||
| 2381 | ( | ||
| 2382 | { | ||
| 2383 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); | ||
| 2384 | } | ||
| 2385 | lv_targetMultiplicity_6_0=ruleMultiplicityDefinition | ||
| 2386 | { | ||
| 2387 | if ($current==null) { | ||
| 2388 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2389 | } | ||
| 2390 | set( | ||
| 2391 | $current, | ||
| 2392 | "targetMultiplicity", | ||
| 2393 | lv_targetMultiplicity_6_0, | ||
| 2394 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 2395 | afterParserOrEnumRuleCall(); | ||
| 2396 | } | ||
| 2397 | ) | ||
| 2398 | )? | ||
| 2399 | ( | ||
| 2400 | ( | ||
| 2401 | { | ||
| 2402 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); | ||
| 2403 | } | ||
| 2404 | lv_target_7_0=ruleSymbol | ||
| 2405 | { | ||
| 2406 | if ($current==null) { | ||
| 2407 | $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 2408 | } | ||
| 2409 | set( | ||
| 2410 | $current, | ||
| 2411 | "target", | ||
| 2412 | lv_target_7_0, | ||
| 2413 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 2414 | afterParserOrEnumRuleCall(); | ||
| 2415 | } | ||
| 2416 | ) | ||
| 2417 | ) | ||
| 2418 | ) | ||
| 2419 | ; | ||
| 2420 | |||
| 2421 | // Entry rule entryRuleMultiplicityDefinition | ||
| 2422 | entryRuleMultiplicityDefinition returns [EObject current=null]: | ||
| 2423 | { newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); } | ||
| 2424 | iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition | ||
| 2425 | { $current=$iv_ruleMultiplicityDefinition.current; } | ||
| 2426 | EOF; | ||
| 2427 | |||
| 2428 | // Rule MultiplicityDefinition | ||
| 2429 | ruleMultiplicityDefinition returns [EObject current=null] | ||
| 2430 | @init { | ||
| 2431 | enterRule(); | ||
| 2432 | } | ||
| 2433 | @after { | ||
| 2434 | leaveRule(); | ||
| 2435 | }: | ||
| 2436 | ( | ||
| 2437 | ( | ||
| 2438 | ( | ||
| 2439 | lv_lower_0_0=RULE_INT | ||
| 2440 | { | ||
| 2441 | newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); | ||
| 2442 | } | ||
| 2443 | { | ||
| 2444 | if ($current==null) { | ||
| 2445 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2446 | } | ||
| 2447 | setWithLastConsumed( | ||
| 2448 | $current, | ||
| 2449 | "lower", | ||
| 2450 | lv_lower_0_0, | ||
| 2451 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2452 | } | ||
| 2453 | ) | ||
| 2454 | ) | ||
| 2455 | otherlv_1='..' | ||
| 2456 | { | ||
| 2457 | newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); | ||
| 2458 | } | ||
| 2459 | ( | ||
| 2460 | ( | ||
| 2461 | ( | ||
| 2462 | lv_upper_2_0=RULE_INT | ||
| 2463 | { | ||
| 2464 | newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); | ||
| 2465 | } | ||
| 2466 | { | ||
| 2467 | if ($current==null) { | ||
| 2468 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2469 | } | ||
| 2470 | setWithLastConsumed( | ||
| 2471 | $current, | ||
| 2472 | "upper", | ||
| 2473 | lv_upper_2_0, | ||
| 2474 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2475 | } | ||
| 2476 | ) | ||
| 2477 | ) | ||
| 2478 | | | ||
| 2479 | ( | ||
| 2480 | ( | ||
| 2481 | lv_unlimitedUpper_3_0='*' | ||
| 2482 | { | ||
| 2483 | newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); | ||
| 2484 | } | ||
| 2485 | { | ||
| 2486 | if ($current==null) { | ||
| 2487 | $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 2488 | } | ||
| 2489 | setWithLastConsumed($current, "unlimitedUpper", true, "*"); | ||
| 2490 | } | ||
| 2491 | ) | ||
| 2492 | ) | ||
| 2493 | ) | ||
| 2494 | ) | ||
| 2495 | ; | ||
| 2496 | |||
| 2497 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
| 2498 | |||
| 2499 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
| 2500 | |||
| 2501 | RULE_INT : ('0'..'9')+; | ||
| 2502 | |||
| 2503 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
| 2504 | |||
| 2505 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
| 2506 | |||
| 2507 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
| 2508 | |||
| 2509 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens deleted file mode 100644 index 5054ccc5..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens +++ /dev/null | |||
| @@ -1,69 +0,0 @@ | |||
| 1 | '('=17 | ||
| 2 | ')'=19 | ||
| 3 | '*'=31 | ||
| 4 | '+'=30 | ||
| 5 | ','=18 | ||
| 6 | '-'=11 | ||
| 7 | '.'=12 | ||
| 8 | '..'=41 | ||
| 9 | ':'=20 | ||
| 10 | ':-'=28 | ||
| 11 | '\''=27 | ||
| 12 | 'abstract'=33 | ||
| 13 | 'bool'=23 | ||
| 14 | 'class'=34 | ||
| 15 | 'containment'=39 | ||
| 16 | 'default'=32 | ||
| 17 | 'enum'=38 | ||
| 18 | 'equals'=22 | ||
| 19 | 'error'=16 | ||
| 20 | 'exists'=21 | ||
| 21 | 'extends'=35 | ||
| 22 | 'false'=14 | ||
| 23 | 'int'=24 | ||
| 24 | 'real'=25 | ||
| 25 | 'relation'=40 | ||
| 26 | 'string'=26 | ||
| 27 | 'true'=13 | ||
| 28 | 'unknown'=15 | ||
| 29 | '{'=36 | ||
| 30 | '|'=29 | ||
| 31 | '}'=37 | ||
| 32 | RULE_ANY_OTHER=10 | ||
| 33 | RULE_ID=5 | ||
| 34 | RULE_INT=4 | ||
| 35 | RULE_ML_COMMENT=7 | ||
| 36 | RULE_SL_COMMENT=8 | ||
| 37 | RULE_STRING=6 | ||
| 38 | RULE_WS=9 | ||
| 39 | T__11=11 | ||
| 40 | T__12=12 | ||
| 41 | T__13=13 | ||
| 42 | T__14=14 | ||
| 43 | T__15=15 | ||
| 44 | T__16=16 | ||
| 45 | T__17=17 | ||
| 46 | T__18=18 | ||
| 47 | T__19=19 | ||
| 48 | T__20=20 | ||
| 49 | T__21=21 | ||
| 50 | T__22=22 | ||
| 51 | T__23=23 | ||
| 52 | T__24=24 | ||
| 53 | T__25=25 | ||
| 54 | T__26=26 | ||
| 55 | T__27=27 | ||
| 56 | T__28=28 | ||
| 57 | T__29=29 | ||
| 58 | T__30=30 | ||
| 59 | T__31=31 | ||
| 60 | T__32=32 | ||
| 61 | T__33=33 | ||
| 62 | T__34=34 | ||
| 63 | T__35=35 | ||
| 64 | T__36=36 | ||
| 65 | T__37=37 | ||
| 66 | T__38=38 | ||
| 67 | T__39=39 | ||
| 68 | T__40=40 | ||
| 69 | T__41=41 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java deleted file mode 100644 index 53c80216..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java +++ /dev/null | |||
| @@ -1,1690 +0,0 @@ | |||
| 1 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 2 | |||
| 3 | // Hack: Use our own Lexer superclass by means of import. | ||
| 4 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 5 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 6 | |||
| 7 | |||
| 8 | import org.antlr.runtime.*; | ||
| 9 | import java.util.Stack; | ||
| 10 | import java.util.List; | ||
| 11 | import java.util.ArrayList; | ||
| 12 | |||
| 13 | @SuppressWarnings("all") | ||
| 14 | public class InternalSolverLanguageLexer extends Lexer { | ||
| 15 | public static final int RULE_STRING=6; | ||
| 16 | public static final int RULE_SL_COMMENT=8; | ||
| 17 | public static final int T__19=19; | ||
| 18 | public static final int T__15=15; | ||
| 19 | public static final int T__37=37; | ||
| 20 | public static final int T__16=16; | ||
| 21 | public static final int T__38=38; | ||
| 22 | public static final int T__17=17; | ||
| 23 | public static final int T__39=39; | ||
| 24 | public static final int T__18=18; | ||
| 25 | public static final int T__11=11; | ||
| 26 | public static final int T__33=33; | ||
| 27 | public static final int T__12=12; | ||
| 28 | public static final int T__34=34; | ||
| 29 | public static final int T__13=13; | ||
| 30 | public static final int T__35=35; | ||
| 31 | public static final int T__14=14; | ||
| 32 | public static final int T__36=36; | ||
| 33 | public static final int EOF=-1; | ||
| 34 | public static final int T__30=30; | ||
| 35 | public static final int T__31=31; | ||
| 36 | public static final int T__32=32; | ||
| 37 | public static final int RULE_ID=5; | ||
| 38 | public static final int RULE_WS=9; | ||
| 39 | public static final int RULE_ANY_OTHER=10; | ||
| 40 | public static final int T__26=26; | ||
| 41 | public static final int T__27=27; | ||
| 42 | public static final int T__28=28; | ||
| 43 | public static final int RULE_INT=4; | ||
| 44 | public static final int T__29=29; | ||
| 45 | public static final int T__22=22; | ||
| 46 | public static final int RULE_ML_COMMENT=7; | ||
| 47 | public static final int T__23=23; | ||
| 48 | public static final int T__24=24; | ||
| 49 | public static final int T__25=25; | ||
| 50 | public static final int T__40=40; | ||
| 51 | public static final int T__41=41; | ||
| 52 | public static final int T__20=20; | ||
| 53 | public static final int T__21=21; | ||
| 54 | |||
| 55 | // delegates | ||
| 56 | // delegators | ||
| 57 | |||
| 58 | public InternalSolverLanguageLexer() {;} | ||
| 59 | public InternalSolverLanguageLexer(CharStream input) { | ||
| 60 | this(input, new RecognizerSharedState()); | ||
| 61 | } | ||
| 62 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
| 63 | super(input,state); | ||
| 64 | |||
| 65 | } | ||
| 66 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | ||
| 67 | |||
| 68 | // $ANTLR start "T__11" | ||
| 69 | public final void mT__11() throws RecognitionException { | ||
| 70 | try { | ||
| 71 | int _type = T__11; | ||
| 72 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 73 | // InternalSolverLanguage.g:11:7: ( '-' ) | ||
| 74 | // InternalSolverLanguage.g:11:9: '-' | ||
| 75 | { | ||
| 76 | match('-'); | ||
| 77 | |||
| 78 | } | ||
| 79 | |||
| 80 | state.type = _type; | ||
| 81 | state.channel = _channel; | ||
| 82 | } | ||
| 83 | finally { | ||
| 84 | } | ||
| 85 | } | ||
| 86 | // $ANTLR end "T__11" | ||
| 87 | |||
| 88 | // $ANTLR start "T__12" | ||
| 89 | public final void mT__12() throws RecognitionException { | ||
| 90 | try { | ||
| 91 | int _type = T__12; | ||
| 92 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 93 | // InternalSolverLanguage.g:12:7: ( '.' ) | ||
| 94 | // InternalSolverLanguage.g:12:9: '.' | ||
| 95 | { | ||
| 96 | match('.'); | ||
| 97 | |||
| 98 | } | ||
| 99 | |||
| 100 | state.type = _type; | ||
| 101 | state.channel = _channel; | ||
| 102 | } | ||
| 103 | finally { | ||
| 104 | } | ||
| 105 | } | ||
| 106 | // $ANTLR end "T__12" | ||
| 107 | |||
| 108 | // $ANTLR start "T__13" | ||
| 109 | public final void mT__13() throws RecognitionException { | ||
| 110 | try { | ||
| 111 | int _type = T__13; | ||
| 112 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 113 | // InternalSolverLanguage.g:13:7: ( 'true' ) | ||
| 114 | // InternalSolverLanguage.g:13:9: 'true' | ||
| 115 | { | ||
| 116 | match("true"); | ||
| 117 | |||
| 118 | |||
| 119 | } | ||
| 120 | |||
| 121 | state.type = _type; | ||
| 122 | state.channel = _channel; | ||
| 123 | } | ||
| 124 | finally { | ||
| 125 | } | ||
| 126 | } | ||
| 127 | // $ANTLR end "T__13" | ||
| 128 | |||
| 129 | // $ANTLR start "T__14" | ||
| 130 | public final void mT__14() throws RecognitionException { | ||
| 131 | try { | ||
| 132 | int _type = T__14; | ||
| 133 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 134 | // InternalSolverLanguage.g:14:7: ( 'false' ) | ||
| 135 | // InternalSolverLanguage.g:14:9: 'false' | ||
| 136 | { | ||
| 137 | match("false"); | ||
| 138 | |||
| 139 | |||
| 140 | } | ||
| 141 | |||
| 142 | state.type = _type; | ||
| 143 | state.channel = _channel; | ||
| 144 | } | ||
| 145 | finally { | ||
| 146 | } | ||
| 147 | } | ||
| 148 | // $ANTLR end "T__14" | ||
| 149 | |||
| 150 | // $ANTLR start "T__15" | ||
| 151 | public final void mT__15() throws RecognitionException { | ||
| 152 | try { | ||
| 153 | int _type = T__15; | ||
| 154 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 155 | // InternalSolverLanguage.g:15:7: ( 'unknown' ) | ||
| 156 | // InternalSolverLanguage.g:15:9: 'unknown' | ||
| 157 | { | ||
| 158 | match("unknown"); | ||
| 159 | |||
| 160 | |||
| 161 | } | ||
| 162 | |||
| 163 | state.type = _type; | ||
| 164 | state.channel = _channel; | ||
| 165 | } | ||
| 166 | finally { | ||
| 167 | } | ||
| 168 | } | ||
| 169 | // $ANTLR end "T__15" | ||
| 170 | |||
| 171 | // $ANTLR start "T__16" | ||
| 172 | public final void mT__16() throws RecognitionException { | ||
| 173 | try { | ||
| 174 | int _type = T__16; | ||
| 175 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 176 | // InternalSolverLanguage.g:16:7: ( 'error' ) | ||
| 177 | // InternalSolverLanguage.g:16:9: 'error' | ||
| 178 | { | ||
| 179 | match("error"); | ||
| 180 | |||
| 181 | |||
| 182 | } | ||
| 183 | |||
| 184 | state.type = _type; | ||
| 185 | state.channel = _channel; | ||
| 186 | } | ||
| 187 | finally { | ||
| 188 | } | ||
| 189 | } | ||
| 190 | // $ANTLR end "T__16" | ||
| 191 | |||
| 192 | // $ANTLR start "T__17" | ||
| 193 | public final void mT__17() throws RecognitionException { | ||
| 194 | try { | ||
| 195 | int _type = T__17; | ||
| 196 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 197 | // InternalSolverLanguage.g:17:7: ( '(' ) | ||
| 198 | // InternalSolverLanguage.g:17:9: '(' | ||
| 199 | { | ||
| 200 | match('('); | ||
| 201 | |||
| 202 | } | ||
| 203 | |||
| 204 | state.type = _type; | ||
| 205 | state.channel = _channel; | ||
| 206 | } | ||
| 207 | finally { | ||
| 208 | } | ||
| 209 | } | ||
| 210 | // $ANTLR end "T__17" | ||
| 211 | |||
| 212 | // $ANTLR start "T__18" | ||
| 213 | public final void mT__18() throws RecognitionException { | ||
| 214 | try { | ||
| 215 | int _type = T__18; | ||
| 216 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 217 | // InternalSolverLanguage.g:18:7: ( ',' ) | ||
| 218 | // InternalSolverLanguage.g:18:9: ',' | ||
| 219 | { | ||
| 220 | match(','); | ||
| 221 | |||
| 222 | } | ||
| 223 | |||
| 224 | state.type = _type; | ||
| 225 | state.channel = _channel; | ||
| 226 | } | ||
| 227 | finally { | ||
| 228 | } | ||
| 229 | } | ||
| 230 | // $ANTLR end "T__18" | ||
| 231 | |||
| 232 | // $ANTLR start "T__19" | ||
| 233 | public final void mT__19() throws RecognitionException { | ||
| 234 | try { | ||
| 235 | int _type = T__19; | ||
| 236 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 237 | // InternalSolverLanguage.g:19:7: ( ')' ) | ||
| 238 | // InternalSolverLanguage.g:19:9: ')' | ||
| 239 | { | ||
| 240 | match(')'); | ||
| 241 | |||
| 242 | } | ||
| 243 | |||
| 244 | state.type = _type; | ||
| 245 | state.channel = _channel; | ||
| 246 | } | ||
| 247 | finally { | ||
| 248 | } | ||
| 249 | } | ||
| 250 | // $ANTLR end "T__19" | ||
| 251 | |||
| 252 | // $ANTLR start "T__20" | ||
| 253 | public final void mT__20() throws RecognitionException { | ||
| 254 | try { | ||
| 255 | int _type = T__20; | ||
| 256 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 257 | // InternalSolverLanguage.g:20:7: ( ':' ) | ||
| 258 | // InternalSolverLanguage.g:20:9: ':' | ||
| 259 | { | ||
| 260 | match(':'); | ||
| 261 | |||
| 262 | } | ||
| 263 | |||
| 264 | state.type = _type; | ||
| 265 | state.channel = _channel; | ||
| 266 | } | ||
| 267 | finally { | ||
| 268 | } | ||
| 269 | } | ||
| 270 | // $ANTLR end "T__20" | ||
| 271 | |||
| 272 | // $ANTLR start "T__21" | ||
| 273 | public final void mT__21() throws RecognitionException { | ||
| 274 | try { | ||
| 275 | int _type = T__21; | ||
| 276 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 277 | // InternalSolverLanguage.g:21:7: ( 'exists' ) | ||
| 278 | // InternalSolverLanguage.g:21:9: 'exists' | ||
| 279 | { | ||
| 280 | match("exists"); | ||
| 281 | |||
| 282 | |||
| 283 | } | ||
| 284 | |||
| 285 | state.type = _type; | ||
| 286 | state.channel = _channel; | ||
| 287 | } | ||
| 288 | finally { | ||
| 289 | } | ||
| 290 | } | ||
| 291 | // $ANTLR end "T__21" | ||
| 292 | |||
| 293 | // $ANTLR start "T__22" | ||
| 294 | public final void mT__22() throws RecognitionException { | ||
| 295 | try { | ||
| 296 | int _type = T__22; | ||
| 297 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 298 | // InternalSolverLanguage.g:22:7: ( 'equals' ) | ||
| 299 | // InternalSolverLanguage.g:22:9: 'equals' | ||
| 300 | { | ||
| 301 | match("equals"); | ||
| 302 | |||
| 303 | |||
| 304 | } | ||
| 305 | |||
| 306 | state.type = _type; | ||
| 307 | state.channel = _channel; | ||
| 308 | } | ||
| 309 | finally { | ||
| 310 | } | ||
| 311 | } | ||
| 312 | // $ANTLR end "T__22" | ||
| 313 | |||
| 314 | // $ANTLR start "T__23" | ||
| 315 | public final void mT__23() throws RecognitionException { | ||
| 316 | try { | ||
| 317 | int _type = T__23; | ||
| 318 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 319 | // InternalSolverLanguage.g:23:7: ( 'bool' ) | ||
| 320 | // InternalSolverLanguage.g:23:9: 'bool' | ||
| 321 | { | ||
| 322 | match("bool"); | ||
| 323 | |||
| 324 | |||
| 325 | } | ||
| 326 | |||
| 327 | state.type = _type; | ||
| 328 | state.channel = _channel; | ||
| 329 | } | ||
| 330 | finally { | ||
| 331 | } | ||
| 332 | } | ||
| 333 | // $ANTLR end "T__23" | ||
| 334 | |||
| 335 | // $ANTLR start "T__24" | ||
| 336 | public final void mT__24() throws RecognitionException { | ||
| 337 | try { | ||
| 338 | int _type = T__24; | ||
| 339 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 340 | // InternalSolverLanguage.g:24:7: ( 'int' ) | ||
| 341 | // InternalSolverLanguage.g:24:9: 'int' | ||
| 342 | { | ||
| 343 | match("int"); | ||
| 344 | |||
| 345 | |||
| 346 | } | ||
| 347 | |||
| 348 | state.type = _type; | ||
| 349 | state.channel = _channel; | ||
| 350 | } | ||
| 351 | finally { | ||
| 352 | } | ||
| 353 | } | ||
| 354 | // $ANTLR end "T__24" | ||
| 355 | |||
| 356 | // $ANTLR start "T__25" | ||
| 357 | public final void mT__25() throws RecognitionException { | ||
| 358 | try { | ||
| 359 | int _type = T__25; | ||
| 360 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 361 | // InternalSolverLanguage.g:25:7: ( 'real' ) | ||
| 362 | // InternalSolverLanguage.g:25:9: 'real' | ||
| 363 | { | ||
| 364 | match("real"); | ||
| 365 | |||
| 366 | |||
| 367 | } | ||
| 368 | |||
| 369 | state.type = _type; | ||
| 370 | state.channel = _channel; | ||
| 371 | } | ||
| 372 | finally { | ||
| 373 | } | ||
| 374 | } | ||
| 375 | // $ANTLR end "T__25" | ||
| 376 | |||
| 377 | // $ANTLR start "T__26" | ||
| 378 | public final void mT__26() throws RecognitionException { | ||
| 379 | try { | ||
| 380 | int _type = T__26; | ||
| 381 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 382 | // InternalSolverLanguage.g:26:7: ( 'string' ) | ||
| 383 | // InternalSolverLanguage.g:26:9: 'string' | ||
| 384 | { | ||
| 385 | match("string"); | ||
| 386 | |||
| 387 | |||
| 388 | } | ||
| 389 | |||
| 390 | state.type = _type; | ||
| 391 | state.channel = _channel; | ||
| 392 | } | ||
| 393 | finally { | ||
| 394 | } | ||
| 395 | } | ||
| 396 | // $ANTLR end "T__26" | ||
| 397 | |||
| 398 | // $ANTLR start "T__27" | ||
| 399 | public final void mT__27() throws RecognitionException { | ||
| 400 | try { | ||
| 401 | int _type = T__27; | ||
| 402 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 403 | // InternalSolverLanguage.g:27:7: ( '\\'' ) | ||
| 404 | // InternalSolverLanguage.g:27:9: '\\'' | ||
| 405 | { | ||
| 406 | match('\''); | ||
| 407 | |||
| 408 | } | ||
| 409 | |||
| 410 | state.type = _type; | ||
| 411 | state.channel = _channel; | ||
| 412 | } | ||
| 413 | finally { | ||
| 414 | } | ||
| 415 | } | ||
| 416 | // $ANTLR end "T__27" | ||
| 417 | |||
| 418 | // $ANTLR start "T__28" | ||
| 419 | public final void mT__28() throws RecognitionException { | ||
| 420 | try { | ||
| 421 | int _type = T__28; | ||
| 422 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 423 | // InternalSolverLanguage.g:28:7: ( ':-' ) | ||
| 424 | // InternalSolverLanguage.g:28:9: ':-' | ||
| 425 | { | ||
| 426 | match(":-"); | ||
| 427 | |||
| 428 | |||
| 429 | } | ||
| 430 | |||
| 431 | state.type = _type; | ||
| 432 | state.channel = _channel; | ||
| 433 | } | ||
| 434 | finally { | ||
| 435 | } | ||
| 436 | } | ||
| 437 | // $ANTLR end "T__28" | ||
| 438 | |||
| 439 | // $ANTLR start "T__29" | ||
| 440 | public final void mT__29() throws RecognitionException { | ||
| 441 | try { | ||
| 442 | int _type = T__29; | ||
| 443 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 444 | // InternalSolverLanguage.g:29:7: ( '|' ) | ||
| 445 | // InternalSolverLanguage.g:29:9: '|' | ||
| 446 | { | ||
| 447 | match('|'); | ||
| 448 | |||
| 449 | } | ||
| 450 | |||
| 451 | state.type = _type; | ||
| 452 | state.channel = _channel; | ||
| 453 | } | ||
| 454 | finally { | ||
| 455 | } | ||
| 456 | } | ||
| 457 | // $ANTLR end "T__29" | ||
| 458 | |||
| 459 | // $ANTLR start "T__30" | ||
| 460 | public final void mT__30() throws RecognitionException { | ||
| 461 | try { | ||
| 462 | int _type = T__30; | ||
| 463 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 464 | // InternalSolverLanguage.g:30:7: ( '+' ) | ||
| 465 | // InternalSolverLanguage.g:30:9: '+' | ||
| 466 | { | ||
| 467 | match('+'); | ||
| 468 | |||
| 469 | } | ||
| 470 | |||
| 471 | state.type = _type; | ||
| 472 | state.channel = _channel; | ||
| 473 | } | ||
| 474 | finally { | ||
| 475 | } | ||
| 476 | } | ||
| 477 | // $ANTLR end "T__30" | ||
| 478 | |||
| 479 | // $ANTLR start "T__31" | ||
| 480 | public final void mT__31() throws RecognitionException { | ||
| 481 | try { | ||
| 482 | int _type = T__31; | ||
| 483 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 484 | // InternalSolverLanguage.g:31:7: ( '*' ) | ||
| 485 | // InternalSolverLanguage.g:31:9: '*' | ||
| 486 | { | ||
| 487 | match('*'); | ||
| 488 | |||
| 489 | } | ||
| 490 | |||
| 491 | state.type = _type; | ||
| 492 | state.channel = _channel; | ||
| 493 | } | ||
| 494 | finally { | ||
| 495 | } | ||
| 496 | } | ||
| 497 | // $ANTLR end "T__31" | ||
| 498 | |||
| 499 | // $ANTLR start "T__32" | ||
| 500 | public final void mT__32() throws RecognitionException { | ||
| 501 | try { | ||
| 502 | int _type = T__32; | ||
| 503 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 504 | // InternalSolverLanguage.g:32:7: ( 'default' ) | ||
| 505 | // InternalSolverLanguage.g:32:9: 'default' | ||
| 506 | { | ||
| 507 | match("default"); | ||
| 508 | |||
| 509 | |||
| 510 | } | ||
| 511 | |||
| 512 | state.type = _type; | ||
| 513 | state.channel = _channel; | ||
| 514 | } | ||
| 515 | finally { | ||
| 516 | } | ||
| 517 | } | ||
| 518 | // $ANTLR end "T__32" | ||
| 519 | |||
| 520 | // $ANTLR start "T__33" | ||
| 521 | public final void mT__33() throws RecognitionException { | ||
| 522 | try { | ||
| 523 | int _type = T__33; | ||
| 524 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 525 | // InternalSolverLanguage.g:33:7: ( 'abstract' ) | ||
| 526 | // InternalSolverLanguage.g:33:9: 'abstract' | ||
| 527 | { | ||
| 528 | match("abstract"); | ||
| 529 | |||
| 530 | |||
| 531 | } | ||
| 532 | |||
| 533 | state.type = _type; | ||
| 534 | state.channel = _channel; | ||
| 535 | } | ||
| 536 | finally { | ||
| 537 | } | ||
| 538 | } | ||
| 539 | // $ANTLR end "T__33" | ||
| 540 | |||
| 541 | // $ANTLR start "T__34" | ||
| 542 | public final void mT__34() throws RecognitionException { | ||
| 543 | try { | ||
| 544 | int _type = T__34; | ||
| 545 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 546 | // InternalSolverLanguage.g:34:7: ( 'class' ) | ||
| 547 | // InternalSolverLanguage.g:34:9: 'class' | ||
| 548 | { | ||
| 549 | match("class"); | ||
| 550 | |||
| 551 | |||
| 552 | } | ||
| 553 | |||
| 554 | state.type = _type; | ||
| 555 | state.channel = _channel; | ||
| 556 | } | ||
| 557 | finally { | ||
| 558 | } | ||
| 559 | } | ||
| 560 | // $ANTLR end "T__34" | ||
| 561 | |||
| 562 | // $ANTLR start "T__35" | ||
| 563 | public final void mT__35() throws RecognitionException { | ||
| 564 | try { | ||
| 565 | int _type = T__35; | ||
| 566 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 567 | // InternalSolverLanguage.g:35:7: ( 'extends' ) | ||
| 568 | // InternalSolverLanguage.g:35:9: 'extends' | ||
| 569 | { | ||
| 570 | match("extends"); | ||
| 571 | |||
| 572 | |||
| 573 | } | ||
| 574 | |||
| 575 | state.type = _type; | ||
| 576 | state.channel = _channel; | ||
| 577 | } | ||
| 578 | finally { | ||
| 579 | } | ||
| 580 | } | ||
| 581 | // $ANTLR end "T__35" | ||
| 582 | |||
| 583 | // $ANTLR start "T__36" | ||
| 584 | public final void mT__36() throws RecognitionException { | ||
| 585 | try { | ||
| 586 | int _type = T__36; | ||
| 587 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 588 | // InternalSolverLanguage.g:36:7: ( '{' ) | ||
| 589 | // InternalSolverLanguage.g:36:9: '{' | ||
| 590 | { | ||
| 591 | match('{'); | ||
| 592 | |||
| 593 | } | ||
| 594 | |||
| 595 | state.type = _type; | ||
| 596 | state.channel = _channel; | ||
| 597 | } | ||
| 598 | finally { | ||
| 599 | } | ||
| 600 | } | ||
| 601 | // $ANTLR end "T__36" | ||
| 602 | |||
| 603 | // $ANTLR start "T__37" | ||
| 604 | public final void mT__37() throws RecognitionException { | ||
| 605 | try { | ||
| 606 | int _type = T__37; | ||
| 607 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 608 | // InternalSolverLanguage.g:37:7: ( '}' ) | ||
| 609 | // InternalSolverLanguage.g:37:9: '}' | ||
| 610 | { | ||
| 611 | match('}'); | ||
| 612 | |||
| 613 | } | ||
| 614 | |||
| 615 | state.type = _type; | ||
| 616 | state.channel = _channel; | ||
| 617 | } | ||
| 618 | finally { | ||
| 619 | } | ||
| 620 | } | ||
| 621 | // $ANTLR end "T__37" | ||
| 622 | |||
| 623 | // $ANTLR start "T__38" | ||
| 624 | public final void mT__38() throws RecognitionException { | ||
| 625 | try { | ||
| 626 | int _type = T__38; | ||
| 627 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 628 | // InternalSolverLanguage.g:38:7: ( 'enum' ) | ||
| 629 | // InternalSolverLanguage.g:38:9: 'enum' | ||
| 630 | { | ||
| 631 | match("enum"); | ||
| 632 | |||
| 633 | |||
| 634 | } | ||
| 635 | |||
| 636 | state.type = _type; | ||
| 637 | state.channel = _channel; | ||
| 638 | } | ||
| 639 | finally { | ||
| 640 | } | ||
| 641 | } | ||
| 642 | // $ANTLR end "T__38" | ||
| 643 | |||
| 644 | // $ANTLR start "T__39" | ||
| 645 | public final void mT__39() throws RecognitionException { | ||
| 646 | try { | ||
| 647 | int _type = T__39; | ||
| 648 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 649 | // InternalSolverLanguage.g:39:7: ( 'containment' ) | ||
| 650 | // InternalSolverLanguage.g:39:9: 'containment' | ||
| 651 | { | ||
| 652 | match("containment"); | ||
| 653 | |||
| 654 | |||
| 655 | } | ||
| 656 | |||
| 657 | state.type = _type; | ||
| 658 | state.channel = _channel; | ||
| 659 | } | ||
| 660 | finally { | ||
| 661 | } | ||
| 662 | } | ||
| 663 | // $ANTLR end "T__39" | ||
| 664 | |||
| 665 | // $ANTLR start "T__40" | ||
| 666 | public final void mT__40() throws RecognitionException { | ||
| 667 | try { | ||
| 668 | int _type = T__40; | ||
| 669 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 670 | // InternalSolverLanguage.g:40:7: ( 'relation' ) | ||
| 671 | // InternalSolverLanguage.g:40:9: 'relation' | ||
| 672 | { | ||
| 673 | match("relation"); | ||
| 674 | |||
| 675 | |||
| 676 | } | ||
| 677 | |||
| 678 | state.type = _type; | ||
| 679 | state.channel = _channel; | ||
| 680 | } | ||
| 681 | finally { | ||
| 682 | } | ||
| 683 | } | ||
| 684 | // $ANTLR end "T__40" | ||
| 685 | |||
| 686 | // $ANTLR start "T__41" | ||
| 687 | public final void mT__41() throws RecognitionException { | ||
| 688 | try { | ||
| 689 | int _type = T__41; | ||
| 690 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 691 | // InternalSolverLanguage.g:41:7: ( '..' ) | ||
| 692 | // InternalSolverLanguage.g:41:9: '..' | ||
| 693 | { | ||
| 694 | match(".."); | ||
| 695 | |||
| 696 | |||
| 697 | } | ||
| 698 | |||
| 699 | state.type = _type; | ||
| 700 | state.channel = _channel; | ||
| 701 | } | ||
| 702 | finally { | ||
| 703 | } | ||
| 704 | } | ||
| 705 | // $ANTLR end "T__41" | ||
| 706 | |||
| 707 | // $ANTLR start "RULE_STRING" | ||
| 708 | public final void mRULE_STRING() throws RecognitionException { | ||
| 709 | try { | ||
| 710 | int _type = RULE_STRING; | ||
| 711 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 712 | // InternalSolverLanguage.g:2497:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
| 713 | // InternalSolverLanguage.g:2497:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
| 714 | { | ||
| 715 | match('\"'); | ||
| 716 | // InternalSolverLanguage.g:2497:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
| 717 | loop1: | ||
| 718 | do { | ||
| 719 | int alt1=3; | ||
| 720 | int LA1_0 = input.LA(1); | ||
| 721 | |||
| 722 | if ( (LA1_0=='\\') ) { | ||
| 723 | alt1=1; | ||
| 724 | } | ||
| 725 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
| 726 | alt1=2; | ||
| 727 | } | ||
| 728 | |||
| 729 | |||
| 730 | switch (alt1) { | ||
| 731 | case 1 : | ||
| 732 | // InternalSolverLanguage.g:2497:20: '\\\\' . | ||
| 733 | { | ||
| 734 | match('\\'); | ||
| 735 | matchAny(); | ||
| 736 | |||
| 737 | } | ||
| 738 | break; | ||
| 739 | case 2 : | ||
| 740 | // InternalSolverLanguage.g:2497:27: ~ ( ( '\\\\' | '\"' ) ) | ||
| 741 | { | ||
| 742 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
| 743 | input.consume(); | ||
| 744 | |||
| 745 | } | ||
| 746 | else { | ||
| 747 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 748 | recover(mse); | ||
| 749 | throw mse;} | ||
| 750 | |||
| 751 | |||
| 752 | } | ||
| 753 | break; | ||
| 754 | |||
| 755 | default : | ||
| 756 | break loop1; | ||
| 757 | } | ||
| 758 | } while (true); | ||
| 759 | |||
| 760 | match('\"'); | ||
| 761 | |||
| 762 | } | ||
| 763 | |||
| 764 | state.type = _type; | ||
| 765 | state.channel = _channel; | ||
| 766 | } | ||
| 767 | finally { | ||
| 768 | } | ||
| 769 | } | ||
| 770 | // $ANTLR end "RULE_STRING" | ||
| 771 | |||
| 772 | // $ANTLR start "RULE_ID" | ||
| 773 | public final void mRULE_ID() throws RecognitionException { | ||
| 774 | try { | ||
| 775 | int _type = RULE_ID; | ||
| 776 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 777 | // InternalSolverLanguage.g:2499:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
| 778 | // InternalSolverLanguage.g:2499:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 779 | { | ||
| 780 | // InternalSolverLanguage.g:2499:11: ( '^' )? | ||
| 781 | int alt2=2; | ||
| 782 | int LA2_0 = input.LA(1); | ||
| 783 | |||
| 784 | if ( (LA2_0=='^') ) { | ||
| 785 | alt2=1; | ||
| 786 | } | ||
| 787 | switch (alt2) { | ||
| 788 | case 1 : | ||
| 789 | // InternalSolverLanguage.g:2499:11: '^' | ||
| 790 | { | ||
| 791 | match('^'); | ||
| 792 | |||
| 793 | } | ||
| 794 | break; | ||
| 795 | |||
| 796 | } | ||
| 797 | |||
| 798 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 799 | input.consume(); | ||
| 800 | |||
| 801 | } | ||
| 802 | else { | ||
| 803 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 804 | recover(mse); | ||
| 805 | throw mse;} | ||
| 806 | |||
| 807 | // InternalSolverLanguage.g:2499:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 808 | loop3: | ||
| 809 | do { | ||
| 810 | int alt3=2; | ||
| 811 | int LA3_0 = input.LA(1); | ||
| 812 | |||
| 813 | if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) { | ||
| 814 | alt3=1; | ||
| 815 | } | ||
| 816 | |||
| 817 | |||
| 818 | switch (alt3) { | ||
| 819 | case 1 : | ||
| 820 | // InternalSolverLanguage.g: | ||
| 821 | { | ||
| 822 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 823 | input.consume(); | ||
| 824 | |||
| 825 | } | ||
| 826 | else { | ||
| 827 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 828 | recover(mse); | ||
| 829 | throw mse;} | ||
| 830 | |||
| 831 | |||
| 832 | } | ||
| 833 | break; | ||
| 834 | |||
| 835 | default : | ||
| 836 | break loop3; | ||
| 837 | } | ||
| 838 | } while (true); | ||
| 839 | |||
| 840 | |||
| 841 | } | ||
| 842 | |||
| 843 | state.type = _type; | ||
| 844 | state.channel = _channel; | ||
| 845 | } | ||
| 846 | finally { | ||
| 847 | } | ||
| 848 | } | ||
| 849 | // $ANTLR end "RULE_ID" | ||
| 850 | |||
| 851 | // $ANTLR start "RULE_INT" | ||
| 852 | public final void mRULE_INT() throws RecognitionException { | ||
| 853 | try { | ||
| 854 | int _type = RULE_INT; | ||
| 855 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 856 | // InternalSolverLanguage.g:2501:10: ( ( '0' .. '9' )+ ) | ||
| 857 | // InternalSolverLanguage.g:2501:12: ( '0' .. '9' )+ | ||
| 858 | { | ||
| 859 | // InternalSolverLanguage.g:2501:12: ( '0' .. '9' )+ | ||
| 860 | int cnt4=0; | ||
| 861 | loop4: | ||
| 862 | do { | ||
| 863 | int alt4=2; | ||
| 864 | int LA4_0 = input.LA(1); | ||
| 865 | |||
| 866 | if ( ((LA4_0>='0' && LA4_0<='9')) ) { | ||
| 867 | alt4=1; | ||
| 868 | } | ||
| 869 | |||
| 870 | |||
| 871 | switch (alt4) { | ||
| 872 | case 1 : | ||
| 873 | // InternalSolverLanguage.g:2501:13: '0' .. '9' | ||
| 874 | { | ||
| 875 | matchRange('0','9'); | ||
| 876 | |||
| 877 | } | ||
| 878 | break; | ||
| 879 | |||
| 880 | default : | ||
| 881 | if ( cnt4 >= 1 ) break loop4; | ||
| 882 | EarlyExitException eee = | ||
| 883 | new EarlyExitException(4, input); | ||
| 884 | throw eee; | ||
| 885 | } | ||
| 886 | cnt4++; | ||
| 887 | } while (true); | ||
| 888 | |||
| 889 | |||
| 890 | } | ||
| 891 | |||
| 892 | state.type = _type; | ||
| 893 | state.channel = _channel; | ||
| 894 | } | ||
| 895 | finally { | ||
| 896 | } | ||
| 897 | } | ||
| 898 | // $ANTLR end "RULE_INT" | ||
| 899 | |||
| 900 | // $ANTLR start "RULE_ML_COMMENT" | ||
| 901 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
| 902 | try { | ||
| 903 | int _type = RULE_ML_COMMENT; | ||
| 904 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 905 | // InternalSolverLanguage.g:2503:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
| 906 | // InternalSolverLanguage.g:2503:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
| 907 | { | ||
| 908 | match("/*"); | ||
| 909 | |||
| 910 | // InternalSolverLanguage.g:2503:24: ( options {greedy=false; } : . )* | ||
| 911 | loop5: | ||
| 912 | do { | ||
| 913 | int alt5=2; | ||
| 914 | int LA5_0 = input.LA(1); | ||
| 915 | |||
| 916 | if ( (LA5_0=='*') ) { | ||
| 917 | int LA5_1 = input.LA(2); | ||
| 918 | |||
| 919 | if ( (LA5_1=='/') ) { | ||
| 920 | alt5=2; | ||
| 921 | } | ||
| 922 | else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) { | ||
| 923 | alt5=1; | ||
| 924 | } | ||
| 925 | |||
| 926 | |||
| 927 | } | ||
| 928 | else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) { | ||
| 929 | alt5=1; | ||
| 930 | } | ||
| 931 | |||
| 932 | |||
| 933 | switch (alt5) { | ||
| 934 | case 1 : | ||
| 935 | // InternalSolverLanguage.g:2503:52: . | ||
| 936 | { | ||
| 937 | matchAny(); | ||
| 938 | |||
| 939 | } | ||
| 940 | break; | ||
| 941 | |||
| 942 | default : | ||
| 943 | break loop5; | ||
| 944 | } | ||
| 945 | } while (true); | ||
| 946 | |||
| 947 | match("*/"); | ||
| 948 | |||
| 949 | |||
| 950 | } | ||
| 951 | |||
| 952 | state.type = _type; | ||
| 953 | state.channel = _channel; | ||
| 954 | } | ||
| 955 | finally { | ||
| 956 | } | ||
| 957 | } | ||
| 958 | // $ANTLR end "RULE_ML_COMMENT" | ||
| 959 | |||
| 960 | // $ANTLR start "RULE_SL_COMMENT" | ||
| 961 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
| 962 | try { | ||
| 963 | int _type = RULE_SL_COMMENT; | ||
| 964 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 965 | // InternalSolverLanguage.g:2505:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
| 966 | // InternalSolverLanguage.g:2505:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
| 967 | { | ||
| 968 | match("//"); | ||
| 969 | |||
| 970 | // InternalSolverLanguage.g:2505:24: (~ ( ( '\\n' | '\\r' ) ) )* | ||
| 971 | loop6: | ||
| 972 | do { | ||
| 973 | int alt6=2; | ||
| 974 | int LA6_0 = input.LA(1); | ||
| 975 | |||
| 976 | if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { | ||
| 977 | alt6=1; | ||
| 978 | } | ||
| 979 | |||
| 980 | |||
| 981 | switch (alt6) { | ||
| 982 | case 1 : | ||
| 983 | // InternalSolverLanguage.g:2505:24: ~ ( ( '\\n' | '\\r' ) ) | ||
| 984 | { | ||
| 985 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { | ||
| 986 | input.consume(); | ||
| 987 | |||
| 988 | } | ||
| 989 | else { | ||
| 990 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 991 | recover(mse); | ||
| 992 | throw mse;} | ||
| 993 | |||
| 994 | |||
| 995 | } | ||
| 996 | break; | ||
| 997 | |||
| 998 | default : | ||
| 999 | break loop6; | ||
| 1000 | } | ||
| 1001 | } while (true); | ||
| 1002 | |||
| 1003 | // InternalSolverLanguage.g:2505:40: ( ( '\\r' )? '\\n' )? | ||
| 1004 | int alt8=2; | ||
| 1005 | int LA8_0 = input.LA(1); | ||
| 1006 | |||
| 1007 | if ( (LA8_0=='\n'||LA8_0=='\r') ) { | ||
| 1008 | alt8=1; | ||
| 1009 | } | ||
| 1010 | switch (alt8) { | ||
| 1011 | case 1 : | ||
| 1012 | // InternalSolverLanguage.g:2505:41: ( '\\r' )? '\\n' | ||
| 1013 | { | ||
| 1014 | // InternalSolverLanguage.g:2505:41: ( '\\r' )? | ||
| 1015 | int alt7=2; | ||
| 1016 | int LA7_0 = input.LA(1); | ||
| 1017 | |||
| 1018 | if ( (LA7_0=='\r') ) { | ||
| 1019 | alt7=1; | ||
| 1020 | } | ||
| 1021 | switch (alt7) { | ||
| 1022 | case 1 : | ||
| 1023 | // InternalSolverLanguage.g:2505:41: '\\r' | ||
| 1024 | { | ||
| 1025 | match('\r'); | ||
| 1026 | |||
| 1027 | } | ||
| 1028 | break; | ||
| 1029 | |||
| 1030 | } | ||
| 1031 | |||
| 1032 | match('\n'); | ||
| 1033 | |||
| 1034 | } | ||
| 1035 | break; | ||
| 1036 | |||
| 1037 | } | ||
| 1038 | |||
| 1039 | |||
| 1040 | } | ||
| 1041 | |||
| 1042 | state.type = _type; | ||
| 1043 | state.channel = _channel; | ||
| 1044 | } | ||
| 1045 | finally { | ||
| 1046 | } | ||
| 1047 | } | ||
| 1048 | // $ANTLR end "RULE_SL_COMMENT" | ||
| 1049 | |||
| 1050 | // $ANTLR start "RULE_WS" | ||
| 1051 | public final void mRULE_WS() throws RecognitionException { | ||
| 1052 | try { | ||
| 1053 | int _type = RULE_WS; | ||
| 1054 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1055 | // InternalSolverLanguage.g:2507:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
| 1056 | // InternalSolverLanguage.g:2507:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 1057 | { | ||
| 1058 | // InternalSolverLanguage.g:2507:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 1059 | int cnt9=0; | ||
| 1060 | loop9: | ||
| 1061 | do { | ||
| 1062 | int alt9=2; | ||
| 1063 | int LA9_0 = input.LA(1); | ||
| 1064 | |||
| 1065 | if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) { | ||
| 1066 | alt9=1; | ||
| 1067 | } | ||
| 1068 | |||
| 1069 | |||
| 1070 | switch (alt9) { | ||
| 1071 | case 1 : | ||
| 1072 | // InternalSolverLanguage.g: | ||
| 1073 | { | ||
| 1074 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
| 1075 | input.consume(); | ||
| 1076 | |||
| 1077 | } | ||
| 1078 | else { | ||
| 1079 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1080 | recover(mse); | ||
| 1081 | throw mse;} | ||
| 1082 | |||
| 1083 | |||
| 1084 | } | ||
| 1085 | break; | ||
| 1086 | |||
| 1087 | default : | ||
| 1088 | if ( cnt9 >= 1 ) break loop9; | ||
| 1089 | EarlyExitException eee = | ||
| 1090 | new EarlyExitException(9, input); | ||
| 1091 | throw eee; | ||
| 1092 | } | ||
| 1093 | cnt9++; | ||
| 1094 | } while (true); | ||
| 1095 | |||
| 1096 | |||
| 1097 | } | ||
| 1098 | |||
| 1099 | state.type = _type; | ||
| 1100 | state.channel = _channel; | ||
| 1101 | } | ||
| 1102 | finally { | ||
| 1103 | } | ||
| 1104 | } | ||
| 1105 | // $ANTLR end "RULE_WS" | ||
| 1106 | |||
| 1107 | // $ANTLR start "RULE_ANY_OTHER" | ||
| 1108 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
| 1109 | try { | ||
| 1110 | int _type = RULE_ANY_OTHER; | ||
| 1111 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1112 | // InternalSolverLanguage.g:2509:16: ( . ) | ||
| 1113 | // InternalSolverLanguage.g:2509:18: . | ||
| 1114 | { | ||
| 1115 | matchAny(); | ||
| 1116 | |||
| 1117 | } | ||
| 1118 | |||
| 1119 | state.type = _type; | ||
| 1120 | state.channel = _channel; | ||
| 1121 | } | ||
| 1122 | finally { | ||
| 1123 | } | ||
| 1124 | } | ||
| 1125 | // $ANTLR end "RULE_ANY_OTHER" | ||
| 1126 | |||
| 1127 | public void mTokens() throws RecognitionException { | ||
| 1128 | // InternalSolverLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
| 1129 | int alt10=38; | ||
| 1130 | alt10 = dfa10.predict(input); | ||
| 1131 | switch (alt10) { | ||
| 1132 | case 1 : | ||
| 1133 | // InternalSolverLanguage.g:1:10: T__11 | ||
| 1134 | { | ||
| 1135 | mT__11(); | ||
| 1136 | |||
| 1137 | } | ||
| 1138 | break; | ||
| 1139 | case 2 : | ||
| 1140 | // InternalSolverLanguage.g:1:16: T__12 | ||
| 1141 | { | ||
| 1142 | mT__12(); | ||
| 1143 | |||
| 1144 | } | ||
| 1145 | break; | ||
| 1146 | case 3 : | ||
| 1147 | // InternalSolverLanguage.g:1:22: T__13 | ||
| 1148 | { | ||
| 1149 | mT__13(); | ||
| 1150 | |||
| 1151 | } | ||
| 1152 | break; | ||
| 1153 | case 4 : | ||
| 1154 | // InternalSolverLanguage.g:1:28: T__14 | ||
| 1155 | { | ||
| 1156 | mT__14(); | ||
| 1157 | |||
| 1158 | } | ||
| 1159 | break; | ||
| 1160 | case 5 : | ||
| 1161 | // InternalSolverLanguage.g:1:34: T__15 | ||
| 1162 | { | ||
| 1163 | mT__15(); | ||
| 1164 | |||
| 1165 | } | ||
| 1166 | break; | ||
| 1167 | case 6 : | ||
| 1168 | // InternalSolverLanguage.g:1:40: T__16 | ||
| 1169 | { | ||
| 1170 | mT__16(); | ||
| 1171 | |||
| 1172 | } | ||
| 1173 | break; | ||
| 1174 | case 7 : | ||
| 1175 | // InternalSolverLanguage.g:1:46: T__17 | ||
| 1176 | { | ||
| 1177 | mT__17(); | ||
| 1178 | |||
| 1179 | } | ||
| 1180 | break; | ||
| 1181 | case 8 : | ||
| 1182 | // InternalSolverLanguage.g:1:52: T__18 | ||
| 1183 | { | ||
| 1184 | mT__18(); | ||
| 1185 | |||
| 1186 | } | ||
| 1187 | break; | ||
| 1188 | case 9 : | ||
| 1189 | // InternalSolverLanguage.g:1:58: T__19 | ||
| 1190 | { | ||
| 1191 | mT__19(); | ||
| 1192 | |||
| 1193 | } | ||
| 1194 | break; | ||
| 1195 | case 10 : | ||
| 1196 | // InternalSolverLanguage.g:1:64: T__20 | ||
| 1197 | { | ||
| 1198 | mT__20(); | ||
| 1199 | |||
| 1200 | } | ||
| 1201 | break; | ||
| 1202 | case 11 : | ||
| 1203 | // InternalSolverLanguage.g:1:70: T__21 | ||
| 1204 | { | ||
| 1205 | mT__21(); | ||
| 1206 | |||
| 1207 | } | ||
| 1208 | break; | ||
| 1209 | case 12 : | ||
| 1210 | // InternalSolverLanguage.g:1:76: T__22 | ||
| 1211 | { | ||
| 1212 | mT__22(); | ||
| 1213 | |||
| 1214 | } | ||
| 1215 | break; | ||
| 1216 | case 13 : | ||
| 1217 | // InternalSolverLanguage.g:1:82: T__23 | ||
| 1218 | { | ||
| 1219 | mT__23(); | ||
| 1220 | |||
| 1221 | } | ||
| 1222 | break; | ||
| 1223 | case 14 : | ||
| 1224 | // InternalSolverLanguage.g:1:88: T__24 | ||
| 1225 | { | ||
| 1226 | mT__24(); | ||
| 1227 | |||
| 1228 | } | ||
| 1229 | break; | ||
| 1230 | case 15 : | ||
| 1231 | // InternalSolverLanguage.g:1:94: T__25 | ||
| 1232 | { | ||
| 1233 | mT__25(); | ||
| 1234 | |||
| 1235 | } | ||
| 1236 | break; | ||
| 1237 | case 16 : | ||
| 1238 | // InternalSolverLanguage.g:1:100: T__26 | ||
| 1239 | { | ||
| 1240 | mT__26(); | ||
| 1241 | |||
| 1242 | } | ||
| 1243 | break; | ||
| 1244 | case 17 : | ||
| 1245 | // InternalSolverLanguage.g:1:106: T__27 | ||
| 1246 | { | ||
| 1247 | mT__27(); | ||
| 1248 | |||
| 1249 | } | ||
| 1250 | break; | ||
| 1251 | case 18 : | ||
| 1252 | // InternalSolverLanguage.g:1:112: T__28 | ||
| 1253 | { | ||
| 1254 | mT__28(); | ||
| 1255 | |||
| 1256 | } | ||
| 1257 | break; | ||
| 1258 | case 19 : | ||
| 1259 | // InternalSolverLanguage.g:1:118: T__29 | ||
| 1260 | { | ||
| 1261 | mT__29(); | ||
| 1262 | |||
| 1263 | } | ||
| 1264 | break; | ||
| 1265 | case 20 : | ||
| 1266 | // InternalSolverLanguage.g:1:124: T__30 | ||
| 1267 | { | ||
| 1268 | mT__30(); | ||
| 1269 | |||
| 1270 | } | ||
| 1271 | break; | ||
| 1272 | case 21 : | ||
| 1273 | // InternalSolverLanguage.g:1:130: T__31 | ||
| 1274 | { | ||
| 1275 | mT__31(); | ||
| 1276 | |||
| 1277 | } | ||
| 1278 | break; | ||
| 1279 | case 22 : | ||
| 1280 | // InternalSolverLanguage.g:1:136: T__32 | ||
| 1281 | { | ||
| 1282 | mT__32(); | ||
| 1283 | |||
| 1284 | } | ||
| 1285 | break; | ||
| 1286 | case 23 : | ||
| 1287 | // InternalSolverLanguage.g:1:142: T__33 | ||
| 1288 | { | ||
| 1289 | mT__33(); | ||
| 1290 | |||
| 1291 | } | ||
| 1292 | break; | ||
| 1293 | case 24 : | ||
| 1294 | // InternalSolverLanguage.g:1:148: T__34 | ||
| 1295 | { | ||
| 1296 | mT__34(); | ||
| 1297 | |||
| 1298 | } | ||
| 1299 | break; | ||
| 1300 | case 25 : | ||
| 1301 | // InternalSolverLanguage.g:1:154: T__35 | ||
| 1302 | { | ||
| 1303 | mT__35(); | ||
| 1304 | |||
| 1305 | } | ||
| 1306 | break; | ||
| 1307 | case 26 : | ||
| 1308 | // InternalSolverLanguage.g:1:160: T__36 | ||
| 1309 | { | ||
| 1310 | mT__36(); | ||
| 1311 | |||
| 1312 | } | ||
| 1313 | break; | ||
| 1314 | case 27 : | ||
| 1315 | // InternalSolverLanguage.g:1:166: T__37 | ||
| 1316 | { | ||
| 1317 | mT__37(); | ||
| 1318 | |||
| 1319 | } | ||
| 1320 | break; | ||
| 1321 | case 28 : | ||
| 1322 | // InternalSolverLanguage.g:1:172: T__38 | ||
| 1323 | { | ||
| 1324 | mT__38(); | ||
| 1325 | |||
| 1326 | } | ||
| 1327 | break; | ||
| 1328 | case 29 : | ||
| 1329 | // InternalSolverLanguage.g:1:178: T__39 | ||
| 1330 | { | ||
| 1331 | mT__39(); | ||
| 1332 | |||
| 1333 | } | ||
| 1334 | break; | ||
| 1335 | case 30 : | ||
| 1336 | // InternalSolverLanguage.g:1:184: T__40 | ||
| 1337 | { | ||
| 1338 | mT__40(); | ||
| 1339 | |||
| 1340 | } | ||
| 1341 | break; | ||
| 1342 | case 31 : | ||
| 1343 | // InternalSolverLanguage.g:1:190: T__41 | ||
| 1344 | { | ||
| 1345 | mT__41(); | ||
| 1346 | |||
| 1347 | } | ||
| 1348 | break; | ||
| 1349 | case 32 : | ||
| 1350 | // InternalSolverLanguage.g:1:196: RULE_STRING | ||
| 1351 | { | ||
| 1352 | mRULE_STRING(); | ||
| 1353 | |||
| 1354 | } | ||
| 1355 | break; | ||
| 1356 | case 33 : | ||
| 1357 | // InternalSolverLanguage.g:1:208: RULE_ID | ||
| 1358 | { | ||
| 1359 | mRULE_ID(); | ||
| 1360 | |||
| 1361 | } | ||
| 1362 | break; | ||
| 1363 | case 34 : | ||
| 1364 | // InternalSolverLanguage.g:1:216: RULE_INT | ||
| 1365 | { | ||
| 1366 | mRULE_INT(); | ||
| 1367 | |||
| 1368 | } | ||
| 1369 | break; | ||
| 1370 | case 35 : | ||
| 1371 | // InternalSolverLanguage.g:1:225: RULE_ML_COMMENT | ||
| 1372 | { | ||
| 1373 | mRULE_ML_COMMENT(); | ||
| 1374 | |||
| 1375 | } | ||
| 1376 | break; | ||
| 1377 | case 36 : | ||
| 1378 | // InternalSolverLanguage.g:1:241: RULE_SL_COMMENT | ||
| 1379 | { | ||
| 1380 | mRULE_SL_COMMENT(); | ||
| 1381 | |||
| 1382 | } | ||
| 1383 | break; | ||
| 1384 | case 37 : | ||
| 1385 | // InternalSolverLanguage.g:1:257: RULE_WS | ||
| 1386 | { | ||
| 1387 | mRULE_WS(); | ||
| 1388 | |||
| 1389 | } | ||
| 1390 | break; | ||
| 1391 | case 38 : | ||
| 1392 | // InternalSolverLanguage.g:1:265: RULE_ANY_OTHER | ||
| 1393 | { | ||
| 1394 | mRULE_ANY_OTHER(); | ||
| 1395 | |||
| 1396 | } | ||
| 1397 | break; | ||
| 1398 | |||
| 1399 | } | ||
| 1400 | |||
| 1401 | } | ||
| 1402 | |||
| 1403 | |||
| 1404 | protected DFA10 dfa10 = new DFA10(this); | ||
| 1405 | static final String DFA10_eotS = | ||
| 1406 | "\2\uffff\1\41\4\43\3\uffff\1\56\4\43\4\uffff\3\43\2\uffff\2\36\2\uffff\1\36\5\uffff\1\43\1\uffff\6\43\5\uffff\4\43\4\uffff\4\43\7\uffff\11\43\1\134\7\43\1\144\6\43\1\153\1\154\1\uffff\1\155\6\43\1\uffff\1\164\1\43\1\166\3\43\3\uffff\4\43\1\176\1\43\1\uffff\1\43\1\uffff\1\u0081\1\43\1\u0083\1\43\1\u0085\2\43\1\uffff\1\43\1\u0089\1\uffff\1\u008a\1\uffff\1\43\1\uffff\1\u008c\2\43\2\uffff\1\u008f\1\uffff\1\u0090\1\43\2\uffff\2\43\1\u0094\1\uffff"; | ||
| 1407 | static final String DFA10_eofS = | ||
| 1408 | "\u0095\uffff"; | ||
| 1409 | static final String DFA10_minS = | ||
| 1410 | "\1\0\1\uffff\1\56\1\162\1\141\2\156\3\uffff\1\55\1\157\1\156\1\145\1\164\4\uffff\1\145\1\142\1\154\2\uffff\1\0\1\101\2\uffff\1\52\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\151\2\165\5\uffff\1\157\1\164\1\141\1\162\4\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\60\1\154\1\141\1\151\1\141\1\164\1\163\1\164\1\60\1\145\1\157\1\162\1\164\1\156\1\154\2\60\1\uffff\1\60\1\164\1\156\1\165\1\162\1\163\1\141\1\uffff\1\60\1\167\1\60\1\163\1\144\1\163\3\uffff\1\151\1\147\1\154\1\141\1\60\1\151\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\164\1\143\1\uffff\1\156\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\60\1\164\1\155\2\uffff\1\60\1\uffff\1\60\1\145\2\uffff\1\156\1\164\1\60\1\uffff"; | ||
| 1411 | static final String DFA10_maxS = | ||
| 1412 | "\1\uffff\1\uffff\1\56\1\162\1\141\1\156\1\170\3\uffff\1\55\1\157\1\156\1\145\1\164\4\uffff\1\145\1\142\1\157\2\uffff\1\uffff\1\172\2\uffff\1\57\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\164\2\165\5\uffff\1\157\1\164\1\154\1\162\4\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\172\1\154\1\141\1\151\1\141\1\164\1\163\1\164\1\172\1\145\1\157\1\162\1\164\1\156\1\154\2\172\1\uffff\1\172\1\164\1\156\1\165\1\162\1\163\1\141\1\uffff\1\172\1\167\1\172\1\163\1\144\1\163\3\uffff\1\151\1\147\1\154\1\141\1\172\1\151\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\164\1\143\1\uffff\1\156\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\172\1\164\1\155\2\uffff\1\172\1\uffff\1\172\1\145\2\uffff\1\156\1\164\1\172\1\uffff"; | ||
| 1413 | static final String DFA10_acceptS = | ||
| 1414 | "\1\uffff\1\1\5\uffff\1\7\1\10\1\11\5\uffff\1\21\1\23\1\24\1\25\3\uffff\1\32\1\33\2\uffff\1\41\1\42\1\uffff\1\45\1\46\1\1\1\37\1\2\1\uffff\1\41\6\uffff\1\7\1\10\1\11\1\22\1\12\4\uffff\1\21\1\23\1\24\1\25\4\uffff\1\32\1\33\1\40\1\42\1\43\1\44\1\45\32\uffff\1\16\7\uffff\1\3\6\uffff\1\34\1\15\1\17\6\uffff\1\4\1\uffff\1\6\7\uffff\1\30\2\uffff\1\13\1\uffff\1\14\1\uffff\1\20\3\uffff\1\5\1\31\1\uffff\1\26\2\uffff\1\36\1\27\3\uffff\1\35"; | ||
| 1415 | static final String DFA10_specialS = | ||
| 1416 | "\1\0\27\uffff\1\1\174\uffff}>"; | ||
| 1417 | static final String[] DFA10_transitionS = { | ||
| 1418 | "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\17\1\7\1\11\1\22\1\21\1\10\1\1\1\2\1\34\12\33\1\12\6\36\32\32\3\36\1\31\1\32\1\36\1\24\1\13\1\25\1\23\1\6\1\4\2\32\1\14\10\32\1\15\1\16\1\3\1\5\5\32\1\26\1\20\1\27\uff82\36", | ||
| 1419 | "", | ||
| 1420 | "\1\40", | ||
| 1421 | "\1\42", | ||
| 1422 | "\1\44", | ||
| 1423 | "\1\45", | ||
| 1424 | "\1\51\2\uffff\1\50\1\46\5\uffff\1\47", | ||
| 1425 | "", | ||
| 1426 | "", | ||
| 1427 | "", | ||
| 1428 | "\1\55", | ||
| 1429 | "\1\57", | ||
| 1430 | "\1\60", | ||
| 1431 | "\1\61", | ||
| 1432 | "\1\62", | ||
| 1433 | "", | ||
| 1434 | "", | ||
| 1435 | "", | ||
| 1436 | "", | ||
| 1437 | "\1\67", | ||
| 1438 | "\1\70", | ||
| 1439 | "\1\71\2\uffff\1\72", | ||
| 1440 | "", | ||
| 1441 | "", | ||
| 1442 | "\0\75", | ||
| 1443 | "\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1444 | "", | ||
| 1445 | "", | ||
| 1446 | "\1\77\4\uffff\1\100", | ||
| 1447 | "", | ||
| 1448 | "", | ||
| 1449 | "", | ||
| 1450 | "", | ||
| 1451 | "", | ||
| 1452 | "\1\102", | ||
| 1453 | "", | ||
| 1454 | "\1\103", | ||
| 1455 | "\1\104", | ||
| 1456 | "\1\105", | ||
| 1457 | "\1\106\12\uffff\1\107", | ||
| 1458 | "\1\110", | ||
| 1459 | "\1\111", | ||
| 1460 | "", | ||
| 1461 | "", | ||
| 1462 | "", | ||
| 1463 | "", | ||
| 1464 | "", | ||
| 1465 | "\1\112", | ||
| 1466 | "\1\113", | ||
| 1467 | "\1\114\12\uffff\1\115", | ||
| 1468 | "\1\116", | ||
| 1469 | "", | ||
| 1470 | "", | ||
| 1471 | "", | ||
| 1472 | "", | ||
| 1473 | "\1\117", | ||
| 1474 | "\1\120", | ||
| 1475 | "\1\121", | ||
| 1476 | "\1\122", | ||
| 1477 | "", | ||
| 1478 | "", | ||
| 1479 | "", | ||
| 1480 | "", | ||
| 1481 | "", | ||
| 1482 | "", | ||
| 1483 | "", | ||
| 1484 | "\1\123", | ||
| 1485 | "\1\124", | ||
| 1486 | "\1\125", | ||
| 1487 | "\1\126", | ||
| 1488 | "\1\127", | ||
| 1489 | "\1\130", | ||
| 1490 | "\1\131", | ||
| 1491 | "\1\132", | ||
| 1492 | "\1\133", | ||
| 1493 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1494 | "\1\135", | ||
| 1495 | "\1\136", | ||
| 1496 | "\1\137", | ||
| 1497 | "\1\140", | ||
| 1498 | "\1\141", | ||
| 1499 | "\1\142", | ||
| 1500 | "\1\143", | ||
| 1501 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1502 | "\1\145", | ||
| 1503 | "\1\146", | ||
| 1504 | "\1\147", | ||
| 1505 | "\1\150", | ||
| 1506 | "\1\151", | ||
| 1507 | "\1\152", | ||
| 1508 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1509 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1510 | "", | ||
| 1511 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1512 | "\1\156", | ||
| 1513 | "\1\157", | ||
| 1514 | "\1\160", | ||
| 1515 | "\1\161", | ||
| 1516 | "\1\162", | ||
| 1517 | "\1\163", | ||
| 1518 | "", | ||
| 1519 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1520 | "\1\165", | ||
| 1521 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1522 | "\1\167", | ||
| 1523 | "\1\170", | ||
| 1524 | "\1\171", | ||
| 1525 | "", | ||
| 1526 | "", | ||
| 1527 | "", | ||
| 1528 | "\1\172", | ||
| 1529 | "\1\173", | ||
| 1530 | "\1\174", | ||
| 1531 | "\1\175", | ||
| 1532 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1533 | "\1\177", | ||
| 1534 | "", | ||
| 1535 | "\1\u0080", | ||
| 1536 | "", | ||
| 1537 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1538 | "\1\u0082", | ||
| 1539 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1540 | "\1\u0084", | ||
| 1541 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1542 | "\1\u0086", | ||
| 1543 | "\1\u0087", | ||
| 1544 | "", | ||
| 1545 | "\1\u0088", | ||
| 1546 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1547 | "", | ||
| 1548 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1549 | "", | ||
| 1550 | "\1\u008b", | ||
| 1551 | "", | ||
| 1552 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1553 | "\1\u008d", | ||
| 1554 | "\1\u008e", | ||
| 1555 | "", | ||
| 1556 | "", | ||
| 1557 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1558 | "", | ||
| 1559 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1560 | "\1\u0091", | ||
| 1561 | "", | ||
| 1562 | "", | ||
| 1563 | "\1\u0092", | ||
| 1564 | "\1\u0093", | ||
| 1565 | "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", | ||
| 1566 | "" | ||
| 1567 | }; | ||
| 1568 | |||
| 1569 | static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); | ||
| 1570 | static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); | ||
| 1571 | static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); | ||
| 1572 | static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); | ||
| 1573 | static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); | ||
| 1574 | static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); | ||
| 1575 | static final short[][] DFA10_transition; | ||
| 1576 | |||
| 1577 | static { | ||
| 1578 | int numStates = DFA10_transitionS.length; | ||
| 1579 | DFA10_transition = new short[numStates][]; | ||
| 1580 | for (int i=0; i<numStates; i++) { | ||
| 1581 | DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]); | ||
| 1582 | } | ||
| 1583 | } | ||
| 1584 | |||
| 1585 | class DFA10 extends DFA { | ||
| 1586 | |||
| 1587 | public DFA10(BaseRecognizer recognizer) { | ||
| 1588 | this.recognizer = recognizer; | ||
| 1589 | this.decisionNumber = 10; | ||
| 1590 | this.eot = DFA10_eot; | ||
| 1591 | this.eof = DFA10_eof; | ||
| 1592 | this.min = DFA10_min; | ||
| 1593 | this.max = DFA10_max; | ||
| 1594 | this.accept = DFA10_accept; | ||
| 1595 | this.special = DFA10_special; | ||
| 1596 | this.transition = DFA10_transition; | ||
| 1597 | } | ||
| 1598 | public String getDescription() { | ||
| 1599 | return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
| 1600 | } | ||
| 1601 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
| 1602 | IntStream input = _input; | ||
| 1603 | int _s = s; | ||
| 1604 | switch ( s ) { | ||
| 1605 | case 0 : | ||
| 1606 | int LA10_0 = input.LA(1); | ||
| 1607 | |||
| 1608 | s = -1; | ||
| 1609 | if ( (LA10_0=='-') ) {s = 1;} | ||
| 1610 | |||
| 1611 | else if ( (LA10_0=='.') ) {s = 2;} | ||
| 1612 | |||
| 1613 | else if ( (LA10_0=='t') ) {s = 3;} | ||
| 1614 | |||
| 1615 | else if ( (LA10_0=='f') ) {s = 4;} | ||
| 1616 | |||
| 1617 | else if ( (LA10_0=='u') ) {s = 5;} | ||
| 1618 | |||
| 1619 | else if ( (LA10_0=='e') ) {s = 6;} | ||
| 1620 | |||
| 1621 | else if ( (LA10_0=='(') ) {s = 7;} | ||
| 1622 | |||
| 1623 | else if ( (LA10_0==',') ) {s = 8;} | ||
| 1624 | |||
| 1625 | else if ( (LA10_0==')') ) {s = 9;} | ||
| 1626 | |||
| 1627 | else if ( (LA10_0==':') ) {s = 10;} | ||
| 1628 | |||
| 1629 | else if ( (LA10_0=='b') ) {s = 11;} | ||
| 1630 | |||
| 1631 | else if ( (LA10_0=='i') ) {s = 12;} | ||
| 1632 | |||
| 1633 | else if ( (LA10_0=='r') ) {s = 13;} | ||
| 1634 | |||
| 1635 | else if ( (LA10_0=='s') ) {s = 14;} | ||
| 1636 | |||
| 1637 | else if ( (LA10_0=='\'') ) {s = 15;} | ||
| 1638 | |||
| 1639 | else if ( (LA10_0=='|') ) {s = 16;} | ||
| 1640 | |||
| 1641 | else if ( (LA10_0=='+') ) {s = 17;} | ||
| 1642 | |||
| 1643 | else if ( (LA10_0=='*') ) {s = 18;} | ||
| 1644 | |||
| 1645 | else if ( (LA10_0=='d') ) {s = 19;} | ||
| 1646 | |||
| 1647 | else if ( (LA10_0=='a') ) {s = 20;} | ||
| 1648 | |||
| 1649 | else if ( (LA10_0=='c') ) {s = 21;} | ||
| 1650 | |||
| 1651 | else if ( (LA10_0=='{') ) {s = 22;} | ||
| 1652 | |||
| 1653 | else if ( (LA10_0=='}') ) {s = 23;} | ||
| 1654 | |||
| 1655 | else if ( (LA10_0=='\"') ) {s = 24;} | ||
| 1656 | |||
| 1657 | else if ( (LA10_0=='^') ) {s = 25;} | ||
| 1658 | |||
| 1659 | else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='q')||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;} | ||
| 1660 | |||
| 1661 | else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;} | ||
| 1662 | |||
| 1663 | else if ( (LA10_0=='/') ) {s = 28;} | ||
| 1664 | |||
| 1665 | else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;} | ||
| 1666 | |||
| 1667 | else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||(LA10_0>=';' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {s = 30;} | ||
| 1668 | |||
| 1669 | if ( s>=0 ) return s; | ||
| 1670 | break; | ||
| 1671 | case 1 : | ||
| 1672 | int LA10_24 = input.LA(1); | ||
| 1673 | |||
| 1674 | s = -1; | ||
| 1675 | if ( ((LA10_24>='\u0000' && LA10_24<='\uFFFF')) ) {s = 61;} | ||
| 1676 | |||
| 1677 | else s = 30; | ||
| 1678 | |||
| 1679 | if ( s>=0 ) return s; | ||
| 1680 | break; | ||
| 1681 | } | ||
| 1682 | NoViableAltException nvae = | ||
| 1683 | new NoViableAltException(getDescription(), 10, _s, input); | ||
| 1684 | error(nvae); | ||
| 1685 | throw nvae; | ||
| 1686 | } | ||
| 1687 | } | ||
| 1688 | |||
| 1689 | |||
| 1690 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g new file mode 100644 index 00000000..6cd0341f --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g | |||
| @@ -0,0 +1,3839 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | parser grammar InternalSolverLanguageParser; | ||
| 5 | |||
| 6 | options { | ||
| 7 | tokenVocab=InternalSolverLanguageLexer; | ||
| 8 | superClass=AbstractInternalAntlrParser; | ||
| 9 | } | ||
| 10 | |||
| 11 | @header { | ||
| 12 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
| 13 | |||
| 14 | import org.eclipse.xtext.*; | ||
| 15 | import org.eclipse.xtext.parser.*; | ||
| 16 | import org.eclipse.xtext.parser.impl.*; | ||
| 17 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
| 18 | import org.eclipse.emf.ecore.EObject; | ||
| 19 | import org.eclipse.emf.common.util.Enumerator; | ||
| 20 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
| 21 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
| 22 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
| 23 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
| 24 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
| 25 | |||
| 26 | } | ||
| 27 | |||
| 28 | @members { | ||
| 29 | |||
| 30 | private SolverLanguageGrammarAccess grammarAccess; | ||
| 31 | |||
| 32 | public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { | ||
| 33 | this(input); | ||
| 34 | this.grammarAccess = grammarAccess; | ||
| 35 | registerRules(grammarAccess.getGrammar()); | ||
| 36 | } | ||
| 37 | |||
| 38 | @Override | ||
| 39 | protected String getFirstRuleName() { | ||
| 40 | return "Problem"; | ||
| 41 | } | ||
| 42 | |||
| 43 | @Override | ||
| 44 | protected SolverLanguageGrammarAccess getGrammarAccess() { | ||
| 45 | return grammarAccess; | ||
| 46 | } | ||
| 47 | |||
| 48 | } | ||
| 49 | |||
| 50 | @rulecatch { | ||
| 51 | catch (RecognitionException re) { | ||
| 52 | recover(input,re); | ||
| 53 | appendSkippedTokens(); | ||
| 54 | } | ||
| 55 | } | ||
| 56 | |||
| 57 | // Entry rule entryRuleProblem | ||
| 58 | entryRuleProblem returns [EObject current=null]: | ||
| 59 | { newCompositeNode(grammarAccess.getProblemRule()); } | ||
| 60 | iv_ruleProblem=ruleProblem | ||
| 61 | { $current=$iv_ruleProblem.current; } | ||
| 62 | EOF; | ||
| 63 | |||
| 64 | // Rule Problem | ||
| 65 | ruleProblem returns [EObject current=null] | ||
| 66 | @init { | ||
| 67 | enterRule(); | ||
| 68 | } | ||
| 69 | @after { | ||
| 70 | leaveRule(); | ||
| 71 | }: | ||
| 72 | ( | ||
| 73 | ( | ||
| 74 | { | ||
| 75 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | ||
| 76 | } | ||
| 77 | lv_statements_0_0=ruleStatement | ||
| 78 | { | ||
| 79 | if ($current==null) { | ||
| 80 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
| 81 | } | ||
| 82 | add( | ||
| 83 | $current, | ||
| 84 | "statements", | ||
| 85 | lv_statements_0_0, | ||
| 86 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
| 87 | afterParserOrEnumRuleCall(); | ||
| 88 | } | ||
| 89 | ) | ||
| 90 | )* | ||
| 91 | ; | ||
| 92 | |||
| 93 | // Entry rule entryRuleStatement | ||
| 94 | entryRuleStatement returns [EObject current=null]: | ||
| 95 | { newCompositeNode(grammarAccess.getStatementRule()); } | ||
| 96 | iv_ruleStatement=ruleStatement | ||
| 97 | { $current=$iv_ruleStatement.current; } | ||
| 98 | EOF; | ||
| 99 | |||
| 100 | // Rule Statement | ||
| 101 | ruleStatement returns [EObject current=null] | ||
| 102 | @init { | ||
| 103 | enterRule(); | ||
| 104 | } | ||
| 105 | @after { | ||
| 106 | leaveRule(); | ||
| 107 | }: | ||
| 108 | ( | ||
| 109 | ( | ||
| 110 | { | ||
| 111 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); | ||
| 112 | } | ||
| 113 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition | ||
| 114 | { | ||
| 115 | $current = $this_AssertionOrDefinition_0.current; | ||
| 116 | afterParserOrEnumRuleCall(); | ||
| 117 | } | ||
| 118 | | | ||
| 119 | { | ||
| 120 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); | ||
| 121 | } | ||
| 122 | this_PredicateDefinition_1=rulePredicateDefinition | ||
| 123 | { | ||
| 124 | $current = $this_PredicateDefinition_1.current; | ||
| 125 | afterParserOrEnumRuleCall(); | ||
| 126 | } | ||
| 127 | | | ||
| 128 | { | ||
| 129 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); | ||
| 130 | } | ||
| 131 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition | ||
| 132 | { | ||
| 133 | $current = $this_UnnamedErrorPrediateDefinition_2.current; | ||
| 134 | afterParserOrEnumRuleCall(); | ||
| 135 | } | ||
| 136 | | | ||
| 137 | { | ||
| 138 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); | ||
| 139 | } | ||
| 140 | this_DefaultDefinition_3=ruleDefaultDefinition | ||
| 141 | { | ||
| 142 | $current = $this_DefaultDefinition_3.current; | ||
| 143 | afterParserOrEnumRuleCall(); | ||
| 144 | } | ||
| 145 | | | ||
| 146 | { | ||
| 147 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | ||
| 148 | } | ||
| 149 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition | ||
| 150 | { | ||
| 151 | $current = $this_ExternPredicateDefinition_4.current; | ||
| 152 | afterParserOrEnumRuleCall(); | ||
| 153 | } | ||
| 154 | | | ||
| 155 | { | ||
| 156 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); | ||
| 157 | } | ||
| 158 | this_MetricDefinition_5=ruleMetricDefinition | ||
| 159 | { | ||
| 160 | $current = $this_MetricDefinition_5.current; | ||
| 161 | afterParserOrEnumRuleCall(); | ||
| 162 | } | ||
| 163 | | | ||
| 164 | { | ||
| 165 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | ||
| 166 | } | ||
| 167 | this_ExternMetricDefinition_6=ruleExternMetricDefinition | ||
| 168 | { | ||
| 169 | $current = $this_ExternMetricDefinition_6.current; | ||
| 170 | afterParserOrEnumRuleCall(); | ||
| 171 | } | ||
| 172 | | | ||
| 173 | { | ||
| 174 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | ||
| 175 | } | ||
| 176 | this_ClassDefinition_7=ruleClassDefinition | ||
| 177 | { | ||
| 178 | $current = $this_ClassDefinition_7.current; | ||
| 179 | afterParserOrEnumRuleCall(); | ||
| 180 | } | ||
| 181 | | | ||
| 182 | { | ||
| 183 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); | ||
| 184 | } | ||
| 185 | this_ScopeDefinition_8=ruleScopeDefinition | ||
| 186 | { | ||
| 187 | $current = $this_ScopeDefinition_8.current; | ||
| 188 | afterParserOrEnumRuleCall(); | ||
| 189 | } | ||
| 190 | | | ||
| 191 | { | ||
| 192 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); | ||
| 193 | } | ||
| 194 | this_ObjectiveDefinition_9=ruleObjectiveDefinition | ||
| 195 | { | ||
| 196 | $current = $this_ObjectiveDefinition_9.current; | ||
| 197 | afterParserOrEnumRuleCall(); | ||
| 198 | } | ||
| 199 | ) | ||
| 200 | this_FULL_STOP_10=RULE_FULL_STOP | ||
| 201 | { | ||
| 202 | newLeafNode(this_FULL_STOP_10, grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); | ||
| 203 | } | ||
| 204 | ) | ||
| 205 | ; | ||
| 206 | |||
| 207 | // Entry rule entryRuleAssertionOrDefinition | ||
| 208 | entryRuleAssertionOrDefinition returns [EObject current=null]: | ||
| 209 | { newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); } | ||
| 210 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition | ||
| 211 | { $current=$iv_ruleAssertionOrDefinition.current; } | ||
| 212 | EOF; | ||
| 213 | |||
| 214 | // Rule AssertionOrDefinition | ||
| 215 | ruleAssertionOrDefinition returns [EObject current=null] | ||
| 216 | @init { | ||
| 217 | enterRule(); | ||
| 218 | } | ||
| 219 | @after { | ||
| 220 | leaveRule(); | ||
| 221 | }: | ||
| 222 | ( | ||
| 223 | { | ||
| 224 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | ||
| 225 | } | ||
| 226 | this_Expression_0=ruleExpression | ||
| 227 | { | ||
| 228 | $current = $this_Expression_0.current; | ||
| 229 | afterParserOrEnumRuleCall(); | ||
| 230 | } | ||
| 231 | ( | ||
| 232 | ( | ||
| 233 | ( | ||
| 234 | { | ||
| 235 | $current = forceCreateModelElementAndSet( | ||
| 236 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), | ||
| 237 | $current); | ||
| 238 | } | ||
| 239 | ) | ||
| 240 | ( | ||
| 241 | otherlv_2=Colon | ||
| 242 | { | ||
| 243 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | ||
| 244 | } | ||
| 245 | ( | ||
| 246 | ( | ||
| 247 | { | ||
| 248 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
| 249 | } | ||
| 250 | lv_range_3_0=ruleExpression | ||
| 251 | { | ||
| 252 | if ($current==null) { | ||
| 253 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 254 | } | ||
| 255 | set( | ||
| 256 | $current, | ||
| 257 | "range", | ||
| 258 | lv_range_3_0, | ||
| 259 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 260 | afterParserOrEnumRuleCall(); | ||
| 261 | } | ||
| 262 | ) | ||
| 263 | ) | ||
| 264 | )? | ||
| 265 | ) | ||
| 266 | | | ||
| 267 | ( | ||
| 268 | ( | ||
| 269 | { | ||
| 270 | $current = forceCreateModelElementAndSet( | ||
| 271 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | ||
| 272 | $current); | ||
| 273 | } | ||
| 274 | ) | ||
| 275 | otherlv_5=ColonHyphenMinus | ||
| 276 | { | ||
| 277 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | ||
| 278 | } | ||
| 279 | ( | ||
| 280 | ( | ||
| 281 | { | ||
| 282 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
| 283 | } | ||
| 284 | lv_body_6_0=ruleExpression | ||
| 285 | { | ||
| 286 | if ($current==null) { | ||
| 287 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 288 | } | ||
| 289 | set( | ||
| 290 | $current, | ||
| 291 | "body", | ||
| 292 | lv_body_6_0, | ||
| 293 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 294 | afterParserOrEnumRuleCall(); | ||
| 295 | } | ||
| 296 | ) | ||
| 297 | ) | ||
| 298 | ) | ||
| 299 | | | ||
| 300 | ( | ||
| 301 | ( | ||
| 302 | { | ||
| 303 | $current = forceCreateModelElementAndSet( | ||
| 304 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), | ||
| 305 | $current); | ||
| 306 | } | ||
| 307 | ) | ||
| 308 | otherlv_8=EqualsSign | ||
| 309 | { | ||
| 310 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | ||
| 311 | } | ||
| 312 | ( | ||
| 313 | ( | ||
| 314 | { | ||
| 315 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
| 316 | } | ||
| 317 | lv_body_9_0=ruleExpression | ||
| 318 | { | ||
| 319 | if ($current==null) { | ||
| 320 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 321 | } | ||
| 322 | set( | ||
| 323 | $current, | ||
| 324 | "body", | ||
| 325 | lv_body_9_0, | ||
| 326 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 327 | afterParserOrEnumRuleCall(); | ||
| 328 | } | ||
| 329 | ) | ||
| 330 | ) | ||
| 331 | ) | ||
| 332 | ) | ||
| 333 | ) | ||
| 334 | ; | ||
| 335 | |||
| 336 | // Entry rule entryRulePredicateDefinition | ||
| 337 | entryRulePredicateDefinition returns [EObject current=null]: | ||
| 338 | { newCompositeNode(grammarAccess.getPredicateDefinitionRule()); } | ||
| 339 | iv_rulePredicateDefinition=rulePredicateDefinition | ||
| 340 | { $current=$iv_rulePredicateDefinition.current; } | ||
| 341 | EOF; | ||
| 342 | |||
| 343 | // Rule PredicateDefinition | ||
| 344 | rulePredicateDefinition returns [EObject current=null] | ||
| 345 | @init { | ||
| 346 | enterRule(); | ||
| 347 | } | ||
| 348 | @after { | ||
| 349 | leaveRule(); | ||
| 350 | }: | ||
| 351 | ( | ||
| 352 | ( | ||
| 353 | ( | ||
| 354 | ( | ||
| 355 | ( | ||
| 356 | lv_functional_0_0=Functional | ||
| 357 | { | ||
| 358 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | ||
| 359 | } | ||
| 360 | { | ||
| 361 | if ($current==null) { | ||
| 362 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 363 | } | ||
| 364 | setWithLastConsumed($current, "functional", true, "functional"); | ||
| 365 | } | ||
| 366 | ) | ||
| 367 | ) | ||
| 368 | ( | ||
| 369 | ( | ||
| 370 | lv_error_1_0=Error | ||
| 371 | { | ||
| 372 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | ||
| 373 | } | ||
| 374 | { | ||
| 375 | if ($current==null) { | ||
| 376 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 377 | } | ||
| 378 | setWithLastConsumed($current, "error", true, "error"); | ||
| 379 | } | ||
| 380 | ) | ||
| 381 | )? | ||
| 382 | ) | ||
| 383 | | | ||
| 384 | ( | ||
| 385 | ( | ||
| 386 | ( | ||
| 387 | lv_error_2_0=Error | ||
| 388 | { | ||
| 389 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
| 390 | } | ||
| 391 | { | ||
| 392 | if ($current==null) { | ||
| 393 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 394 | } | ||
| 395 | setWithLastConsumed($current, "error", true, "error"); | ||
| 396 | } | ||
| 397 | ) | ||
| 398 | ) | ||
| 399 | ( | ||
| 400 | ( | ||
| 401 | lv_functional_3_0=Functional | ||
| 402 | { | ||
| 403 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
| 404 | } | ||
| 405 | { | ||
| 406 | if ($current==null) { | ||
| 407 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 408 | } | ||
| 409 | setWithLastConsumed($current, "functional", true, "functional"); | ||
| 410 | } | ||
| 411 | ) | ||
| 412 | )? | ||
| 413 | ) | ||
| 414 | ) | ||
| 415 | ( | ||
| 416 | ( | ||
| 417 | { | ||
| 418 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 419 | } | ||
| 420 | lv_head_4_0=ruleCall | ||
| 421 | { | ||
| 422 | if ($current==null) { | ||
| 423 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 424 | } | ||
| 425 | set( | ||
| 426 | $current, | ||
| 427 | "head", | ||
| 428 | lv_head_4_0, | ||
| 429 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 430 | afterParserOrEnumRuleCall(); | ||
| 431 | } | ||
| 432 | ) | ||
| 433 | ) | ||
| 434 | otherlv_5=ColonHyphenMinus | ||
| 435 | { | ||
| 436 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 437 | } | ||
| 438 | ( | ||
| 439 | ( | ||
| 440 | { | ||
| 441 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 442 | } | ||
| 443 | lv_body_6_0=ruleExpression | ||
| 444 | { | ||
| 445 | if ($current==null) { | ||
| 446 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 447 | } | ||
| 448 | set( | ||
| 449 | $current, | ||
| 450 | "body", | ||
| 451 | lv_body_6_0, | ||
| 452 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 453 | afterParserOrEnumRuleCall(); | ||
| 454 | } | ||
| 455 | ) | ||
| 456 | ) | ||
| 457 | ) | ||
| 458 | ; | ||
| 459 | |||
| 460 | // Entry rule entryRuleUnnamedErrorPrediateDefinition | ||
| 461 | entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null]: | ||
| 462 | { newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); } | ||
| 463 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition | ||
| 464 | { $current=$iv_ruleUnnamedErrorPrediateDefinition.current; } | ||
| 465 | EOF; | ||
| 466 | |||
| 467 | // Rule UnnamedErrorPrediateDefinition | ||
| 468 | ruleUnnamedErrorPrediateDefinition returns [EObject current=null] | ||
| 469 | @init { | ||
| 470 | enterRule(); | ||
| 471 | } | ||
| 472 | @after { | ||
| 473 | leaveRule(); | ||
| 474 | }: | ||
| 475 | ( | ||
| 476 | otherlv_0=Error | ||
| 477 | { | ||
| 478 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); | ||
| 479 | } | ||
| 480 | ( | ||
| 481 | ( | ||
| 482 | { | ||
| 483 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
| 484 | } | ||
| 485 | lv_argumentList_1_0=ruleArgumentList | ||
| 486 | { | ||
| 487 | if ($current==null) { | ||
| 488 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 489 | } | ||
| 490 | set( | ||
| 491 | $current, | ||
| 492 | "argumentList", | ||
| 493 | lv_argumentList_1_0, | ||
| 494 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 495 | afterParserOrEnumRuleCall(); | ||
| 496 | } | ||
| 497 | ) | ||
| 498 | ) | ||
| 499 | otherlv_2=ColonHyphenMinus | ||
| 500 | { | ||
| 501 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 502 | } | ||
| 503 | ( | ||
| 504 | ( | ||
| 505 | { | ||
| 506 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 507 | } | ||
| 508 | lv_body_3_0=ruleExpression | ||
| 509 | { | ||
| 510 | if ($current==null) { | ||
| 511 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 512 | } | ||
| 513 | set( | ||
| 514 | $current, | ||
| 515 | "body", | ||
| 516 | lv_body_3_0, | ||
| 517 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 518 | afterParserOrEnumRuleCall(); | ||
| 519 | } | ||
| 520 | ) | ||
| 521 | ) | ||
| 522 | ) | ||
| 523 | ; | ||
| 524 | |||
| 525 | // Entry rule entryRuleDefaultDefinition | ||
| 526 | entryRuleDefaultDefinition returns [EObject current=null]: | ||
| 527 | { newCompositeNode(grammarAccess.getDefaultDefinitionRule()); } | ||
| 528 | iv_ruleDefaultDefinition=ruleDefaultDefinition | ||
| 529 | { $current=$iv_ruleDefaultDefinition.current; } | ||
| 530 | EOF; | ||
| 531 | |||
| 532 | // Rule DefaultDefinition | ||
| 533 | ruleDefaultDefinition returns [EObject current=null] | ||
| 534 | @init { | ||
| 535 | enterRule(); | ||
| 536 | } | ||
| 537 | @after { | ||
| 538 | leaveRule(); | ||
| 539 | }: | ||
| 540 | ( | ||
| 541 | otherlv_0=Default | ||
| 542 | { | ||
| 543 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | ||
| 544 | } | ||
| 545 | ( | ||
| 546 | ( | ||
| 547 | { | ||
| 548 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 549 | } | ||
| 550 | lv_head_1_0=ruleCall | ||
| 551 | { | ||
| 552 | if ($current==null) { | ||
| 553 | $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | ||
| 554 | } | ||
| 555 | set( | ||
| 556 | $current, | ||
| 557 | "head", | ||
| 558 | lv_head_1_0, | ||
| 559 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 560 | afterParserOrEnumRuleCall(); | ||
| 561 | } | ||
| 562 | ) | ||
| 563 | ) | ||
| 564 | otherlv_2=Colon | ||
| 565 | { | ||
| 566 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | ||
| 567 | } | ||
| 568 | ( | ||
| 569 | ( | ||
| 570 | { | ||
| 571 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); | ||
| 572 | } | ||
| 573 | lv_range_3_0=ruleExpression | ||
| 574 | { | ||
| 575 | if ($current==null) { | ||
| 576 | $current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | ||
| 577 | } | ||
| 578 | set( | ||
| 579 | $current, | ||
| 580 | "range", | ||
| 581 | lv_range_3_0, | ||
| 582 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 583 | afterParserOrEnumRuleCall(); | ||
| 584 | } | ||
| 585 | ) | ||
| 586 | ) | ||
| 587 | ) | ||
| 588 | ; | ||
| 589 | |||
| 590 | // Entry rule entryRuleExternPredicateDefinition | ||
| 591 | entryRuleExternPredicateDefinition returns [EObject current=null]: | ||
| 592 | { newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); } | ||
| 593 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition | ||
| 594 | { $current=$iv_ruleExternPredicateDefinition.current; } | ||
| 595 | EOF; | ||
| 596 | |||
| 597 | // Rule ExternPredicateDefinition | ||
| 598 | ruleExternPredicateDefinition returns [EObject current=null] | ||
| 599 | @init { | ||
| 600 | enterRule(); | ||
| 601 | } | ||
| 602 | @after { | ||
| 603 | leaveRule(); | ||
| 604 | }: | ||
| 605 | ( | ||
| 606 | otherlv_0=Extern | ||
| 607 | { | ||
| 608 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | ||
| 609 | } | ||
| 610 | ( | ||
| 611 | ( | ||
| 612 | { | ||
| 613 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 614 | } | ||
| 615 | lv_head_1_0=ruleCall | ||
| 616 | { | ||
| 617 | if ($current==null) { | ||
| 618 | $current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); | ||
| 619 | } | ||
| 620 | set( | ||
| 621 | $current, | ||
| 622 | "head", | ||
| 623 | lv_head_1_0, | ||
| 624 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 625 | afterParserOrEnumRuleCall(); | ||
| 626 | } | ||
| 627 | ) | ||
| 628 | ) | ||
| 629 | ) | ||
| 630 | ; | ||
| 631 | |||
| 632 | // Entry rule entryRuleMetricDefinition | ||
| 633 | entryRuleMetricDefinition returns [EObject current=null]: | ||
| 634 | { newCompositeNode(grammarAccess.getMetricDefinitionRule()); } | ||
| 635 | iv_ruleMetricDefinition=ruleMetricDefinition | ||
| 636 | { $current=$iv_ruleMetricDefinition.current; } | ||
| 637 | EOF; | ||
| 638 | |||
| 639 | // Rule MetricDefinition | ||
| 640 | ruleMetricDefinition returns [EObject current=null] | ||
| 641 | @init { | ||
| 642 | enterRule(); | ||
| 643 | } | ||
| 644 | @after { | ||
| 645 | leaveRule(); | ||
| 646 | }: | ||
| 647 | ( | ||
| 648 | ( | ||
| 649 | ( | ||
| 650 | { | ||
| 651 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); | ||
| 652 | } | ||
| 653 | lv_type_0_0=ruleMetricType | ||
| 654 | { | ||
| 655 | if ($current==null) { | ||
| 656 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 657 | } | ||
| 658 | set( | ||
| 659 | $current, | ||
| 660 | "type", | ||
| 661 | lv_type_0_0, | ||
| 662 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 663 | afterParserOrEnumRuleCall(); | ||
| 664 | } | ||
| 665 | ) | ||
| 666 | ) | ||
| 667 | ( | ||
| 668 | ( | ||
| 669 | { | ||
| 670 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); | ||
| 671 | } | ||
| 672 | lv_head_1_0=ruleExpression | ||
| 673 | { | ||
| 674 | if ($current==null) { | ||
| 675 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 676 | } | ||
| 677 | set( | ||
| 678 | $current, | ||
| 679 | "head", | ||
| 680 | lv_head_1_0, | ||
| 681 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 682 | afterParserOrEnumRuleCall(); | ||
| 683 | } | ||
| 684 | ) | ||
| 685 | ) | ||
| 686 | otherlv_2=EqualsSign | ||
| 687 | { | ||
| 688 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | ||
| 689 | } | ||
| 690 | ( | ||
| 691 | ( | ||
| 692 | { | ||
| 693 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 694 | } | ||
| 695 | lv_body_3_0=ruleExpression | ||
| 696 | { | ||
| 697 | if ($current==null) { | ||
| 698 | $current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 699 | } | ||
| 700 | set( | ||
| 701 | $current, | ||
| 702 | "body", | ||
| 703 | lv_body_3_0, | ||
| 704 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 705 | afterParserOrEnumRuleCall(); | ||
| 706 | } | ||
| 707 | ) | ||
| 708 | ) | ||
| 709 | ) | ||
| 710 | ; | ||
| 711 | |||
| 712 | // Entry rule entryRuleExternMetricDefinition | ||
| 713 | entryRuleExternMetricDefinition returns [EObject current=null]: | ||
| 714 | { newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); } | ||
| 715 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition | ||
| 716 | { $current=$iv_ruleExternMetricDefinition.current; } | ||
| 717 | EOF; | ||
| 718 | |||
| 719 | // Rule ExternMetricDefinition | ||
| 720 | ruleExternMetricDefinition returns [EObject current=null] | ||
| 721 | @init { | ||
| 722 | enterRule(); | ||
| 723 | } | ||
| 724 | @after { | ||
| 725 | leaveRule(); | ||
| 726 | }: | ||
| 727 | ( | ||
| 728 | otherlv_0=Extern | ||
| 729 | { | ||
| 730 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | ||
| 731 | } | ||
| 732 | ( | ||
| 733 | ( | ||
| 734 | { | ||
| 735 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | ||
| 736 | } | ||
| 737 | lv_type_1_0=ruleMetricType | ||
| 738 | { | ||
| 739 | if ($current==null) { | ||
| 740 | $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 741 | } | ||
| 742 | set( | ||
| 743 | $current, | ||
| 744 | "type", | ||
| 745 | lv_type_1_0, | ||
| 746 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 747 | afterParserOrEnumRuleCall(); | ||
| 748 | } | ||
| 749 | ) | ||
| 750 | ) | ||
| 751 | ( | ||
| 752 | ( | ||
| 753 | { | ||
| 754 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
| 755 | } | ||
| 756 | lv_head_2_0=ruleCall | ||
| 757 | { | ||
| 758 | if ($current==null) { | ||
| 759 | $current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 760 | } | ||
| 761 | set( | ||
| 762 | $current, | ||
| 763 | "head", | ||
| 764 | lv_head_2_0, | ||
| 765 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 766 | afterParserOrEnumRuleCall(); | ||
| 767 | } | ||
| 768 | ) | ||
| 769 | ) | ||
| 770 | ) | ||
| 771 | ; | ||
| 772 | |||
| 773 | // Entry rule entryRuleExpression | ||
| 774 | entryRuleExpression returns [EObject current=null]: | ||
| 775 | { newCompositeNode(grammarAccess.getExpressionRule()); } | ||
| 776 | iv_ruleExpression=ruleExpression | ||
| 777 | { $current=$iv_ruleExpression.current; } | ||
| 778 | EOF; | ||
| 779 | |||
| 780 | // Rule Expression | ||
| 781 | ruleExpression returns [EObject current=null] | ||
| 782 | @init { | ||
| 783 | enterRule(); | ||
| 784 | } | ||
| 785 | @after { | ||
| 786 | leaveRule(); | ||
| 787 | }: | ||
| 788 | ( | ||
| 789 | { | ||
| 790 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); | ||
| 791 | } | ||
| 792 | this_IfElse_0=ruleIfElse | ||
| 793 | { | ||
| 794 | $current = $this_IfElse_0.current; | ||
| 795 | afterParserOrEnumRuleCall(); | ||
| 796 | } | ||
| 797 | | | ||
| 798 | { | ||
| 799 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); | ||
| 800 | } | ||
| 801 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression | ||
| 802 | { | ||
| 803 | $current = $this_DisjunctiveExpression_1.current; | ||
| 804 | afterParserOrEnumRuleCall(); | ||
| 805 | } | ||
| 806 | ) | ||
| 807 | ; | ||
| 808 | |||
| 809 | // Entry rule entryRuleIfElse | ||
| 810 | entryRuleIfElse returns [EObject current=null]: | ||
| 811 | { newCompositeNode(grammarAccess.getIfElseRule()); } | ||
| 812 | iv_ruleIfElse=ruleIfElse | ||
| 813 | { $current=$iv_ruleIfElse.current; } | ||
| 814 | EOF; | ||
| 815 | |||
| 816 | // Rule IfElse | ||
| 817 | ruleIfElse returns [EObject current=null] | ||
| 818 | @init { | ||
| 819 | enterRule(); | ||
| 820 | } | ||
| 821 | @after { | ||
| 822 | leaveRule(); | ||
| 823 | }: | ||
| 824 | ( | ||
| 825 | otherlv_0=If | ||
| 826 | { | ||
| 827 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); | ||
| 828 | } | ||
| 829 | ( | ||
| 830 | ( | ||
| 831 | { | ||
| 832 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); | ||
| 833 | } | ||
| 834 | lv_condition_1_0=ruleExpression | ||
| 835 | { | ||
| 836 | if ($current==null) { | ||
| 837 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 838 | } | ||
| 839 | set( | ||
| 840 | $current, | ||
| 841 | "condition", | ||
| 842 | lv_condition_1_0, | ||
| 843 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 844 | afterParserOrEnumRuleCall(); | ||
| 845 | } | ||
| 846 | ) | ||
| 847 | ) | ||
| 848 | otherlv_2=Then | ||
| 849 | { | ||
| 850 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | ||
| 851 | } | ||
| 852 | ( | ||
| 853 | ( | ||
| 854 | { | ||
| 855 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
| 856 | } | ||
| 857 | lv_then_3_0=ruleExpression | ||
| 858 | { | ||
| 859 | if ($current==null) { | ||
| 860 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 861 | } | ||
| 862 | set( | ||
| 863 | $current, | ||
| 864 | "then", | ||
| 865 | lv_then_3_0, | ||
| 866 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 867 | afterParserOrEnumRuleCall(); | ||
| 868 | } | ||
| 869 | ) | ||
| 870 | ) | ||
| 871 | otherlv_4=Else | ||
| 872 | { | ||
| 873 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | ||
| 874 | } | ||
| 875 | ( | ||
| 876 | ( | ||
| 877 | { | ||
| 878 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
| 879 | } | ||
| 880 | lv_else_5_0=ruleExpression | ||
| 881 | { | ||
| 882 | if ($current==null) { | ||
| 883 | $current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 884 | } | ||
| 885 | set( | ||
| 886 | $current, | ||
| 887 | "else", | ||
| 888 | lv_else_5_0, | ||
| 889 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 890 | afterParserOrEnumRuleCall(); | ||
| 891 | } | ||
| 892 | ) | ||
| 893 | ) | ||
| 894 | ) | ||
| 895 | ; | ||
| 896 | |||
| 897 | // Entry rule entryRuleDisjunctiveExpression | ||
| 898 | entryRuleDisjunctiveExpression returns [EObject current=null]: | ||
| 899 | { newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); } | ||
| 900 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression | ||
| 901 | { $current=$iv_ruleDisjunctiveExpression.current; } | ||
| 902 | EOF; | ||
| 903 | |||
| 904 | // Rule DisjunctiveExpression | ||
| 905 | ruleDisjunctiveExpression returns [EObject current=null] | ||
| 906 | @init { | ||
| 907 | enterRule(); | ||
| 908 | } | ||
| 909 | @after { | ||
| 910 | leaveRule(); | ||
| 911 | }: | ||
| 912 | ( | ||
| 913 | { | ||
| 914 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
| 915 | } | ||
| 916 | this_ConjunctiveExpression_0=ruleConjunctiveExpression | ||
| 917 | { | ||
| 918 | $current = $this_ConjunctiveExpression_0.current; | ||
| 919 | afterParserOrEnumRuleCall(); | ||
| 920 | } | ||
| 921 | ( | ||
| 922 | ( | ||
| 923 | ( | ||
| 924 | { | ||
| 925 | $current = forceCreateModelElementAndAdd( | ||
| 926 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
| 927 | $current); | ||
| 928 | } | ||
| 929 | ) | ||
| 930 | ( | ||
| 931 | otherlv_2=Semicolon | ||
| 932 | { | ||
| 933 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
| 934 | } | ||
| 935 | ( | ||
| 936 | ( | ||
| 937 | { | ||
| 938 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
| 939 | } | ||
| 940 | lv_children_3_0=ruleConjunctiveExpression | ||
| 941 | { | ||
| 942 | if ($current==null) { | ||
| 943 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 944 | } | ||
| 945 | add( | ||
| 946 | $current, | ||
| 947 | "children", | ||
| 948 | lv_children_3_0, | ||
| 949 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 950 | afterParserOrEnumRuleCall(); | ||
| 951 | } | ||
| 952 | ) | ||
| 953 | ) | ||
| 954 | )+ | ||
| 955 | ) | ||
| 956 | | | ||
| 957 | ( | ||
| 958 | ( | ||
| 959 | { | ||
| 960 | $current = forceCreateModelElementAndSet( | ||
| 961 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
| 962 | $current); | ||
| 963 | } | ||
| 964 | ) | ||
| 965 | otherlv_5=HyphenMinusGreaterThanSign | ||
| 966 | { | ||
| 967 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
| 968 | } | ||
| 969 | ( | ||
| 970 | ( | ||
| 971 | { | ||
| 972 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
| 973 | } | ||
| 974 | lv_body_6_0=ruleConjunctiveExpression | ||
| 975 | { | ||
| 976 | if ($current==null) { | ||
| 977 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 978 | } | ||
| 979 | set( | ||
| 980 | $current, | ||
| 981 | "body", | ||
| 982 | lv_body_6_0, | ||
| 983 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 984 | afterParserOrEnumRuleCall(); | ||
| 985 | } | ||
| 986 | ) | ||
| 987 | ) | ||
| 988 | ( | ||
| 989 | { | ||
| 990 | $current = forceCreateModelElementAndAdd( | ||
| 991 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
| 992 | $current); | ||
| 993 | } | ||
| 994 | ) | ||
| 995 | ( | ||
| 996 | otherlv_8=Semicolon | ||
| 997 | { | ||
| 998 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
| 999 | } | ||
| 1000 | ( | ||
| 1001 | ( | ||
| 1002 | { | ||
| 1003 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
| 1004 | } | ||
| 1005 | lv_cases_9_0=ruleCase | ||
| 1006 | { | ||
| 1007 | if ($current==null) { | ||
| 1008 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 1009 | } | ||
| 1010 | add( | ||
| 1011 | $current, | ||
| 1012 | "cases", | ||
| 1013 | lv_cases_9_0, | ||
| 1014 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
| 1015 | afterParserOrEnumRuleCall(); | ||
| 1016 | } | ||
| 1017 | ) | ||
| 1018 | ) | ||
| 1019 | )* | ||
| 1020 | ) | ||
| 1021 | )? | ||
| 1022 | ) | ||
| 1023 | ; | ||
| 1024 | |||
| 1025 | // Entry rule entryRuleCase | ||
| 1026 | entryRuleCase returns [EObject current=null]: | ||
| 1027 | { newCompositeNode(grammarAccess.getCaseRule()); } | ||
| 1028 | iv_ruleCase=ruleCase | ||
| 1029 | { $current=$iv_ruleCase.current; } | ||
| 1030 | EOF; | ||
| 1031 | |||
| 1032 | // Rule Case | ||
| 1033 | ruleCase returns [EObject current=null] | ||
| 1034 | @init { | ||
| 1035 | enterRule(); | ||
| 1036 | } | ||
| 1037 | @after { | ||
| 1038 | leaveRule(); | ||
| 1039 | }: | ||
| 1040 | ( | ||
| 1041 | ( | ||
| 1042 | ( | ||
| 1043 | { | ||
| 1044 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
| 1045 | } | ||
| 1046 | lv_condition_0_0=ruleConjunctiveExpression | ||
| 1047 | { | ||
| 1048 | if ($current==null) { | ||
| 1049 | $current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 1050 | } | ||
| 1051 | set( | ||
| 1052 | $current, | ||
| 1053 | "condition", | ||
| 1054 | lv_condition_0_0, | ||
| 1055 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 1056 | afterParserOrEnumRuleCall(); | ||
| 1057 | } | ||
| 1058 | ) | ||
| 1059 | ) | ||
| 1060 | otherlv_1=HyphenMinusGreaterThanSign | ||
| 1061 | { | ||
| 1062 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
| 1063 | } | ||
| 1064 | ( | ||
| 1065 | ( | ||
| 1066 | { | ||
| 1067 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
| 1068 | } | ||
| 1069 | lv_body_2_0=ruleConjunctiveExpression | ||
| 1070 | { | ||
| 1071 | if ($current==null) { | ||
| 1072 | $current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 1073 | } | ||
| 1074 | set( | ||
| 1075 | $current, | ||
| 1076 | "body", | ||
| 1077 | lv_body_2_0, | ||
| 1078 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 1079 | afterParserOrEnumRuleCall(); | ||
| 1080 | } | ||
| 1081 | ) | ||
| 1082 | ) | ||
| 1083 | ) | ||
| 1084 | ; | ||
| 1085 | |||
| 1086 | // Entry rule entryRuleConjunctiveExpression | ||
| 1087 | entryRuleConjunctiveExpression returns [EObject current=null]: | ||
| 1088 | { newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); } | ||
| 1089 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression | ||
| 1090 | { $current=$iv_ruleConjunctiveExpression.current; } | ||
| 1091 | EOF; | ||
| 1092 | |||
| 1093 | // Rule ConjunctiveExpression | ||
| 1094 | ruleConjunctiveExpression returns [EObject current=null] | ||
| 1095 | @init { | ||
| 1096 | enterRule(); | ||
| 1097 | } | ||
| 1098 | @after { | ||
| 1099 | leaveRule(); | ||
| 1100 | }: | ||
| 1101 | ( | ||
| 1102 | { | ||
| 1103 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
| 1104 | } | ||
| 1105 | this_ComparisonExpression_0=ruleComparisonExpression | ||
| 1106 | { | ||
| 1107 | $current = $this_ComparisonExpression_0.current; | ||
| 1108 | afterParserOrEnumRuleCall(); | ||
| 1109 | } | ||
| 1110 | ( | ||
| 1111 | ( | ||
| 1112 | { | ||
| 1113 | $current = forceCreateModelElementAndAdd( | ||
| 1114 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | ||
| 1115 | $current); | ||
| 1116 | } | ||
| 1117 | ) | ||
| 1118 | ( | ||
| 1119 | otherlv_2=Comma | ||
| 1120 | { | ||
| 1121 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
| 1122 | } | ||
| 1123 | ( | ||
| 1124 | ( | ||
| 1125 | { | ||
| 1126 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
| 1127 | } | ||
| 1128 | lv_children_3_0=ruleComparisonExpression | ||
| 1129 | { | ||
| 1130 | if ($current==null) { | ||
| 1131 | $current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
| 1132 | } | ||
| 1133 | add( | ||
| 1134 | $current, | ||
| 1135 | "children", | ||
| 1136 | lv_children_3_0, | ||
| 1137 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 1138 | afterParserOrEnumRuleCall(); | ||
| 1139 | } | ||
| 1140 | ) | ||
| 1141 | ) | ||
| 1142 | )+ | ||
| 1143 | )? | ||
| 1144 | ) | ||
| 1145 | ; | ||
| 1146 | |||
| 1147 | // Entry rule entryRuleComparisonExpression | ||
| 1148 | entryRuleComparisonExpression returns [EObject current=null]: | ||
| 1149 | { newCompositeNode(grammarAccess.getComparisonExpressionRule()); } | ||
| 1150 | iv_ruleComparisonExpression=ruleComparisonExpression | ||
| 1151 | { $current=$iv_ruleComparisonExpression.current; } | ||
| 1152 | EOF; | ||
| 1153 | |||
| 1154 | // Rule ComparisonExpression | ||
| 1155 | ruleComparisonExpression returns [EObject current=null] | ||
| 1156 | @init { | ||
| 1157 | enterRule(); | ||
| 1158 | } | ||
| 1159 | @after { | ||
| 1160 | leaveRule(); | ||
| 1161 | }: | ||
| 1162 | ( | ||
| 1163 | { | ||
| 1164 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
| 1165 | } | ||
| 1166 | this_AdditiveExpression_0=ruleAdditiveExpression | ||
| 1167 | { | ||
| 1168 | $current = $this_AdditiveExpression_0.current; | ||
| 1169 | afterParserOrEnumRuleCall(); | ||
| 1170 | } | ||
| 1171 | ( | ||
| 1172 | ( | ||
| 1173 | { | ||
| 1174 | $current = forceCreateModelElementAndSet( | ||
| 1175 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), | ||
| 1176 | $current); | ||
| 1177 | } | ||
| 1178 | ) | ||
| 1179 | ( | ||
| 1180 | ( | ||
| 1181 | { | ||
| 1182 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
| 1183 | } | ||
| 1184 | lv_op_2_0=ruleComparisonOperator | ||
| 1185 | { | ||
| 1186 | if ($current==null) { | ||
| 1187 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 1188 | } | ||
| 1189 | set( | ||
| 1190 | $current, | ||
| 1191 | "op", | ||
| 1192 | lv_op_2_0, | ||
| 1193 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
| 1194 | afterParserOrEnumRuleCall(); | ||
| 1195 | } | ||
| 1196 | ) | ||
| 1197 | ) | ||
| 1198 | ( | ||
| 1199 | ( | ||
| 1200 | { | ||
| 1201 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
| 1202 | } | ||
| 1203 | lv_right_3_0=ruleAdditiveExpression | ||
| 1204 | { | ||
| 1205 | if ($current==null) { | ||
| 1206 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 1207 | } | ||
| 1208 | set( | ||
| 1209 | $current, | ||
| 1210 | "right", | ||
| 1211 | lv_right_3_0, | ||
| 1212 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
| 1213 | afterParserOrEnumRuleCall(); | ||
| 1214 | } | ||
| 1215 | ) | ||
| 1216 | ) | ||
| 1217 | )? | ||
| 1218 | ) | ||
| 1219 | ; | ||
| 1220 | |||
| 1221 | // Entry rule entryRuleAdditiveExpression | ||
| 1222 | entryRuleAdditiveExpression returns [EObject current=null]: | ||
| 1223 | { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); } | ||
| 1224 | iv_ruleAdditiveExpression=ruleAdditiveExpression | ||
| 1225 | { $current=$iv_ruleAdditiveExpression.current; } | ||
| 1226 | EOF; | ||
| 1227 | |||
| 1228 | // Rule AdditiveExpression | ||
| 1229 | ruleAdditiveExpression returns [EObject current=null] | ||
| 1230 | @init { | ||
| 1231 | enterRule(); | ||
| 1232 | } | ||
| 1233 | @after { | ||
| 1234 | leaveRule(); | ||
| 1235 | }: | ||
| 1236 | ( | ||
| 1237 | { | ||
| 1238 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | ||
| 1239 | } | ||
| 1240 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression | ||
| 1241 | { | ||
| 1242 | $current = $this_MultiplicativeExpression_0.current; | ||
| 1243 | afterParserOrEnumRuleCall(); | ||
| 1244 | } | ||
| 1245 | ( | ||
| 1246 | ( | ||
| 1247 | { | ||
| 1248 | $current = forceCreateModelElementAndSet( | ||
| 1249 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 1250 | $current); | ||
| 1251 | } | ||
| 1252 | ) | ||
| 1253 | ( | ||
| 1254 | ( | ||
| 1255 | { | ||
| 1256 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 1257 | } | ||
| 1258 | lv_op_2_0=ruleAdditiveBinaryOperator | ||
| 1259 | { | ||
| 1260 | if ($current==null) { | ||
| 1261 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 1262 | } | ||
| 1263 | set( | ||
| 1264 | $current, | ||
| 1265 | "op", | ||
| 1266 | lv_op_2_0, | ||
| 1267 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
| 1268 | afterParserOrEnumRuleCall(); | ||
| 1269 | } | ||
| 1270 | ) | ||
| 1271 | ) | ||
| 1272 | ( | ||
| 1273 | ( | ||
| 1274 | { | ||
| 1275 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
| 1276 | } | ||
| 1277 | lv_right_3_0=ruleMultiplicativeExpression | ||
| 1278 | { | ||
| 1279 | if ($current==null) { | ||
| 1280 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 1281 | } | ||
| 1282 | set( | ||
| 1283 | $current, | ||
| 1284 | "right", | ||
| 1285 | lv_right_3_0, | ||
| 1286 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
| 1287 | afterParserOrEnumRuleCall(); | ||
| 1288 | } | ||
| 1289 | ) | ||
| 1290 | ) | ||
| 1291 | )* | ||
| 1292 | ) | ||
| 1293 | ; | ||
| 1294 | |||
| 1295 | // Entry rule entryRuleMultiplicativeExpression | ||
| 1296 | entryRuleMultiplicativeExpression returns [EObject current=null]: | ||
| 1297 | { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); } | ||
| 1298 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression | ||
| 1299 | { $current=$iv_ruleMultiplicativeExpression.current; } | ||
| 1300 | EOF; | ||
| 1301 | |||
| 1302 | // Rule MultiplicativeExpression | ||
| 1303 | ruleMultiplicativeExpression returns [EObject current=null] | ||
| 1304 | @init { | ||
| 1305 | enterRule(); | ||
| 1306 | } | ||
| 1307 | @after { | ||
| 1308 | leaveRule(); | ||
| 1309 | }: | ||
| 1310 | ( | ||
| 1311 | { | ||
| 1312 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | ||
| 1313 | } | ||
| 1314 | this_ExponentialExpression_0=ruleExponentialExpression | ||
| 1315 | { | ||
| 1316 | $current = $this_ExponentialExpression_0.current; | ||
| 1317 | afterParserOrEnumRuleCall(); | ||
| 1318 | } | ||
| 1319 | ( | ||
| 1320 | ( | ||
| 1321 | { | ||
| 1322 | $current = forceCreateModelElementAndSet( | ||
| 1323 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 1324 | $current); | ||
| 1325 | } | ||
| 1326 | ) | ||
| 1327 | ( | ||
| 1328 | ( | ||
| 1329 | { | ||
| 1330 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 1331 | } | ||
| 1332 | lv_op_2_0=ruleMultiplicativeBinaryOperator | ||
| 1333 | { | ||
| 1334 | if ($current==null) { | ||
| 1335 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 1336 | } | ||
| 1337 | set( | ||
| 1338 | $current, | ||
| 1339 | "op", | ||
| 1340 | lv_op_2_0, | ||
| 1341 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
| 1342 | afterParserOrEnumRuleCall(); | ||
| 1343 | } | ||
| 1344 | ) | ||
| 1345 | ) | ||
| 1346 | ( | ||
| 1347 | ( | ||
| 1348 | { | ||
| 1349 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 1350 | } | ||
| 1351 | lv_right_3_0=ruleExponentialExpression | ||
| 1352 | { | ||
| 1353 | if ($current==null) { | ||
| 1354 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 1355 | } | ||
| 1356 | set( | ||
| 1357 | $current, | ||
| 1358 | "right", | ||
| 1359 | lv_right_3_0, | ||
| 1360 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 1361 | afterParserOrEnumRuleCall(); | ||
| 1362 | } | ||
| 1363 | ) | ||
| 1364 | ) | ||
| 1365 | )* | ||
| 1366 | ) | ||
| 1367 | ; | ||
| 1368 | |||
| 1369 | // Entry rule entryRuleExponentialExpression | ||
| 1370 | entryRuleExponentialExpression returns [EObject current=null]: | ||
| 1371 | { newCompositeNode(grammarAccess.getExponentialExpressionRule()); } | ||
| 1372 | iv_ruleExponentialExpression=ruleExponentialExpression | ||
| 1373 | { $current=$iv_ruleExponentialExpression.current; } | ||
| 1374 | EOF; | ||
| 1375 | |||
| 1376 | // Rule ExponentialExpression | ||
| 1377 | ruleExponentialExpression returns [EObject current=null] | ||
| 1378 | @init { | ||
| 1379 | enterRule(); | ||
| 1380 | } | ||
| 1381 | @after { | ||
| 1382 | leaveRule(); | ||
| 1383 | }: | ||
| 1384 | ( | ||
| 1385 | { | ||
| 1386 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); | ||
| 1387 | } | ||
| 1388 | this_UnaryExpression_0=ruleUnaryExpression | ||
| 1389 | { | ||
| 1390 | $current = $this_UnaryExpression_0.current; | ||
| 1391 | afterParserOrEnumRuleCall(); | ||
| 1392 | } | ||
| 1393 | ( | ||
| 1394 | ( | ||
| 1395 | { | ||
| 1396 | $current = forceCreateModelElementAndSet( | ||
| 1397 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 1398 | $current); | ||
| 1399 | } | ||
| 1400 | ) | ||
| 1401 | ( | ||
| 1402 | ( | ||
| 1403 | { | ||
| 1404 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
| 1405 | } | ||
| 1406 | lv_op_2_0=ruleExponentialOp | ||
| 1407 | { | ||
| 1408 | if ($current==null) { | ||
| 1409 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 1410 | } | ||
| 1411 | set( | ||
| 1412 | $current, | ||
| 1413 | "op", | ||
| 1414 | lv_op_2_0, | ||
| 1415 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
| 1416 | afterParserOrEnumRuleCall(); | ||
| 1417 | } | ||
| 1418 | ) | ||
| 1419 | ) | ||
| 1420 | ( | ||
| 1421 | ( | ||
| 1422 | { | ||
| 1423 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 1424 | } | ||
| 1425 | lv_right_3_0=ruleExponentialExpression | ||
| 1426 | { | ||
| 1427 | if ($current==null) { | ||
| 1428 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 1429 | } | ||
| 1430 | set( | ||
| 1431 | $current, | ||
| 1432 | "right", | ||
| 1433 | lv_right_3_0, | ||
| 1434 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 1435 | afterParserOrEnumRuleCall(); | ||
| 1436 | } | ||
| 1437 | ) | ||
| 1438 | ) | ||
| 1439 | )? | ||
| 1440 | ) | ||
| 1441 | ; | ||
| 1442 | |||
| 1443 | // Entry rule entryRuleUnaryExpression | ||
| 1444 | entryRuleUnaryExpression returns [EObject current=null]: | ||
| 1445 | { newCompositeNode(grammarAccess.getUnaryExpressionRule()); } | ||
| 1446 | iv_ruleUnaryExpression=ruleUnaryExpression | ||
| 1447 | { $current=$iv_ruleUnaryExpression.current; } | ||
| 1448 | EOF; | ||
| 1449 | |||
| 1450 | // Rule UnaryExpression | ||
| 1451 | ruleUnaryExpression returns [EObject current=null] | ||
| 1452 | @init { | ||
| 1453 | enterRule(); | ||
| 1454 | } | ||
| 1455 | @after { | ||
| 1456 | leaveRule(); | ||
| 1457 | }: | ||
| 1458 | ( | ||
| 1459 | { | ||
| 1460 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); | ||
| 1461 | } | ||
| 1462 | this_AggregationExpression_0=ruleAggregationExpression | ||
| 1463 | { | ||
| 1464 | $current = $this_AggregationExpression_0.current; | ||
| 1465 | afterParserOrEnumRuleCall(); | ||
| 1466 | } | ||
| 1467 | | | ||
| 1468 | ( | ||
| 1469 | ( | ||
| 1470 | { | ||
| 1471 | $current = forceCreateModelElement( | ||
| 1472 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | ||
| 1473 | $current); | ||
| 1474 | } | ||
| 1475 | ) | ||
| 1476 | ( | ||
| 1477 | ( | ||
| 1478 | { | ||
| 1479 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
| 1480 | } | ||
| 1481 | lv_op_2_0=ruleUnaryOp | ||
| 1482 | { | ||
| 1483 | if ($current==null) { | ||
| 1484 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 1485 | } | ||
| 1486 | set( | ||
| 1487 | $current, | ||
| 1488 | "op", | ||
| 1489 | lv_op_2_0, | ||
| 1490 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | ||
| 1491 | afterParserOrEnumRuleCall(); | ||
| 1492 | } | ||
| 1493 | ) | ||
| 1494 | ) | ||
| 1495 | ( | ||
| 1496 | ( | ||
| 1497 | { | ||
| 1498 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); | ||
| 1499 | } | ||
| 1500 | lv_body_3_0=ruleAggregationExpression | ||
| 1501 | { | ||
| 1502 | if ($current==null) { | ||
| 1503 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
| 1504 | } | ||
| 1505 | set( | ||
| 1506 | $current, | ||
| 1507 | "body", | ||
| 1508 | lv_body_3_0, | ||
| 1509 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); | ||
| 1510 | afterParserOrEnumRuleCall(); | ||
| 1511 | } | ||
| 1512 | ) | ||
| 1513 | ) | ||
| 1514 | ) | ||
| 1515 | ) | ||
| 1516 | ; | ||
| 1517 | |||
| 1518 | // Entry rule entryRuleAggregationExpression | ||
| 1519 | entryRuleAggregationExpression returns [EObject current=null]: | ||
| 1520 | { newCompositeNode(grammarAccess.getAggregationExpressionRule()); } | ||
| 1521 | iv_ruleAggregationExpression=ruleAggregationExpression | ||
| 1522 | { $current=$iv_ruleAggregationExpression.current; } | ||
| 1523 | EOF; | ||
| 1524 | |||
| 1525 | // Rule AggregationExpression | ||
| 1526 | ruleAggregationExpression returns [EObject current=null] | ||
| 1527 | @init { | ||
| 1528 | enterRule(); | ||
| 1529 | } | ||
| 1530 | @after { | ||
| 1531 | leaveRule(); | ||
| 1532 | }: | ||
| 1533 | ( | ||
| 1534 | { | ||
| 1535 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); | ||
| 1536 | } | ||
| 1537 | this_AtomicExpression_0=ruleAtomicExpression | ||
| 1538 | { | ||
| 1539 | $current = $this_AtomicExpression_0.current; | ||
| 1540 | afterParserOrEnumRuleCall(); | ||
| 1541 | } | ||
| 1542 | | | ||
| 1543 | { | ||
| 1544 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); | ||
| 1545 | } | ||
| 1546 | this_Count_1=ruleCount | ||
| 1547 | { | ||
| 1548 | $current = $this_Count_1.current; | ||
| 1549 | afterParserOrEnumRuleCall(); | ||
| 1550 | } | ||
| 1551 | | | ||
| 1552 | { | ||
| 1553 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); | ||
| 1554 | } | ||
| 1555 | this_Aggregation_2=ruleAggregation | ||
| 1556 | { | ||
| 1557 | $current = $this_Aggregation_2.current; | ||
| 1558 | afterParserOrEnumRuleCall(); | ||
| 1559 | } | ||
| 1560 | ) | ||
| 1561 | ; | ||
| 1562 | |||
| 1563 | // Entry rule entryRuleCount | ||
| 1564 | entryRuleCount returns [EObject current=null]: | ||
| 1565 | { newCompositeNode(grammarAccess.getCountRule()); } | ||
| 1566 | iv_ruleCount=ruleCount | ||
| 1567 | { $current=$iv_ruleCount.current; } | ||
| 1568 | EOF; | ||
| 1569 | |||
| 1570 | // Rule Count | ||
| 1571 | ruleCount returns [EObject current=null] | ||
| 1572 | @init { | ||
| 1573 | enterRule(); | ||
| 1574 | } | ||
| 1575 | @after { | ||
| 1576 | leaveRule(); | ||
| 1577 | }: | ||
| 1578 | ( | ||
| 1579 | otherlv_0=Count | ||
| 1580 | { | ||
| 1581 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | ||
| 1582 | } | ||
| 1583 | otherlv_1=LeftCurlyBracket | ||
| 1584 | { | ||
| 1585 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | ||
| 1586 | } | ||
| 1587 | ( | ||
| 1588 | ( | ||
| 1589 | { | ||
| 1590 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); | ||
| 1591 | } | ||
| 1592 | lv_body_2_0=ruleExpression | ||
| 1593 | { | ||
| 1594 | if ($current==null) { | ||
| 1595 | $current = createModelElementForParent(grammarAccess.getCountRule()); | ||
| 1596 | } | ||
| 1597 | set( | ||
| 1598 | $current, | ||
| 1599 | "body", | ||
| 1600 | lv_body_2_0, | ||
| 1601 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1602 | afterParserOrEnumRuleCall(); | ||
| 1603 | } | ||
| 1604 | ) | ||
| 1605 | ) | ||
| 1606 | otherlv_3=RightCurlyBracket | ||
| 1607 | { | ||
| 1608 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | ||
| 1609 | } | ||
| 1610 | ) | ||
| 1611 | ; | ||
| 1612 | |||
| 1613 | // Entry rule entryRuleAggregation | ||
| 1614 | entryRuleAggregation returns [EObject current=null]: | ||
| 1615 | { newCompositeNode(grammarAccess.getAggregationRule()); } | ||
| 1616 | iv_ruleAggregation=ruleAggregation | ||
| 1617 | { $current=$iv_ruleAggregation.current; } | ||
| 1618 | EOF; | ||
| 1619 | |||
| 1620 | // Rule Aggregation | ||
| 1621 | ruleAggregation returns [EObject current=null] | ||
| 1622 | @init { | ||
| 1623 | enterRule(); | ||
| 1624 | } | ||
| 1625 | @after { | ||
| 1626 | leaveRule(); | ||
| 1627 | }: | ||
| 1628 | ( | ||
| 1629 | ( | ||
| 1630 | ( | ||
| 1631 | { | ||
| 1632 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | ||
| 1633 | } | ||
| 1634 | lv_op_0_0=ruleAggregationOp | ||
| 1635 | { | ||
| 1636 | if ($current==null) { | ||
| 1637 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1638 | } | ||
| 1639 | set( | ||
| 1640 | $current, | ||
| 1641 | "op", | ||
| 1642 | lv_op_0_0, | ||
| 1643 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); | ||
| 1644 | afterParserOrEnumRuleCall(); | ||
| 1645 | } | ||
| 1646 | ) | ||
| 1647 | ) | ||
| 1648 | otherlv_1=LeftCurlyBracket | ||
| 1649 | { | ||
| 1650 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
| 1651 | } | ||
| 1652 | ( | ||
| 1653 | ( | ||
| 1654 | { | ||
| 1655 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | ||
| 1656 | } | ||
| 1657 | lv_body_2_0=ruleExpression | ||
| 1658 | { | ||
| 1659 | if ($current==null) { | ||
| 1660 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1661 | } | ||
| 1662 | set( | ||
| 1663 | $current, | ||
| 1664 | "body", | ||
| 1665 | lv_body_2_0, | ||
| 1666 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1667 | afterParserOrEnumRuleCall(); | ||
| 1668 | } | ||
| 1669 | ) | ||
| 1670 | ) | ||
| 1671 | otherlv_3=VerticalLine | ||
| 1672 | { | ||
| 1673 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
| 1674 | } | ||
| 1675 | ( | ||
| 1676 | ( | ||
| 1677 | { | ||
| 1678 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
| 1679 | } | ||
| 1680 | lv_condition_4_0=ruleExpression | ||
| 1681 | { | ||
| 1682 | if ($current==null) { | ||
| 1683 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 1684 | } | ||
| 1685 | set( | ||
| 1686 | $current, | ||
| 1687 | "condition", | ||
| 1688 | lv_condition_4_0, | ||
| 1689 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1690 | afterParserOrEnumRuleCall(); | ||
| 1691 | } | ||
| 1692 | ) | ||
| 1693 | ) | ||
| 1694 | otherlv_5=RightCurlyBracket | ||
| 1695 | { | ||
| 1696 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
| 1697 | } | ||
| 1698 | ) | ||
| 1699 | ; | ||
| 1700 | |||
| 1701 | // Entry rule entryRuleAtomicExpression | ||
| 1702 | entryRuleAtomicExpression returns [EObject current=null]: | ||
| 1703 | { newCompositeNode(grammarAccess.getAtomicExpressionRule()); } | ||
| 1704 | iv_ruleAtomicExpression=ruleAtomicExpression | ||
| 1705 | { $current=$iv_ruleAtomicExpression.current; } | ||
| 1706 | EOF; | ||
| 1707 | |||
| 1708 | // Rule AtomicExpression | ||
| 1709 | ruleAtomicExpression returns [EObject current=null] | ||
| 1710 | @init { | ||
| 1711 | enterRule(); | ||
| 1712 | } | ||
| 1713 | @after { | ||
| 1714 | leaveRule(); | ||
| 1715 | }: | ||
| 1716 | ( | ||
| 1717 | { | ||
| 1718 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); | ||
| 1719 | } | ||
| 1720 | this_Reference_0=ruleReference | ||
| 1721 | { | ||
| 1722 | $current = $this_Reference_0.current; | ||
| 1723 | afterParserOrEnumRuleCall(); | ||
| 1724 | } | ||
| 1725 | | | ||
| 1726 | { | ||
| 1727 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
| 1728 | } | ||
| 1729 | this_Call_1=ruleCall | ||
| 1730 | { | ||
| 1731 | $current = $this_Call_1.current; | ||
| 1732 | afterParserOrEnumRuleCall(); | ||
| 1733 | } | ||
| 1734 | | | ||
| 1735 | { | ||
| 1736 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); | ||
| 1737 | } | ||
| 1738 | this_Interval_2=ruleInterval | ||
| 1739 | { | ||
| 1740 | $current = $this_Interval_2.current; | ||
| 1741 | afterParserOrEnumRuleCall(); | ||
| 1742 | } | ||
| 1743 | | | ||
| 1744 | { | ||
| 1745 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); | ||
| 1746 | } | ||
| 1747 | this_Literal_3=ruleLiteral | ||
| 1748 | { | ||
| 1749 | $current = $this_Literal_3.current; | ||
| 1750 | afterParserOrEnumRuleCall(); | ||
| 1751 | } | ||
| 1752 | | | ||
| 1753 | ( | ||
| 1754 | otherlv_4=LeftParenthesis | ||
| 1755 | { | ||
| 1756 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
| 1757 | } | ||
| 1758 | { | ||
| 1759 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); | ||
| 1760 | } | ||
| 1761 | this_Expression_5=ruleExpression | ||
| 1762 | { | ||
| 1763 | $current = $this_Expression_5.current; | ||
| 1764 | afterParserOrEnumRuleCall(); | ||
| 1765 | } | ||
| 1766 | otherlv_6=RightParenthesis | ||
| 1767 | { | ||
| 1768 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); | ||
| 1769 | } | ||
| 1770 | ) | ||
| 1771 | ) | ||
| 1772 | ; | ||
| 1773 | |||
| 1774 | // Entry rule entryRuleCall | ||
| 1775 | entryRuleCall returns [EObject current=null]: | ||
| 1776 | { newCompositeNode(grammarAccess.getCallRule()); } | ||
| 1777 | iv_ruleCall=ruleCall | ||
| 1778 | { $current=$iv_ruleCall.current; } | ||
| 1779 | EOF; | ||
| 1780 | |||
| 1781 | // Rule Call | ||
| 1782 | ruleCall returns [EObject current=null] | ||
| 1783 | @init { | ||
| 1784 | enterRule(); | ||
| 1785 | } | ||
| 1786 | @after { | ||
| 1787 | leaveRule(); | ||
| 1788 | }: | ||
| 1789 | ( | ||
| 1790 | ( | ||
| 1791 | ( | ||
| 1792 | { | ||
| 1793 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
| 1794 | } | ||
| 1795 | lv_functor_0_0=ruleReference | ||
| 1796 | { | ||
| 1797 | if ($current==null) { | ||
| 1798 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 1799 | } | ||
| 1800 | set( | ||
| 1801 | $current, | ||
| 1802 | "functor", | ||
| 1803 | lv_functor_0_0, | ||
| 1804 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
| 1805 | afterParserOrEnumRuleCall(); | ||
| 1806 | } | ||
| 1807 | ) | ||
| 1808 | ) | ||
| 1809 | ( | ||
| 1810 | ( | ||
| 1811 | ( | ||
| 1812 | lv_transitiveClosure_1_0=RULE_TRANSITIVE_CLOSURE | ||
| 1813 | { | ||
| 1814 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); | ||
| 1815 | } | ||
| 1816 | { | ||
| 1817 | if ($current==null) { | ||
| 1818 | $current = createModelElement(grammarAccess.getCallRule()); | ||
| 1819 | } | ||
| 1820 | setWithLastConsumed( | ||
| 1821 | $current, | ||
| 1822 | "transitiveClosure", | ||
| 1823 | true, | ||
| 1824 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
| 1825 | } | ||
| 1826 | ) | ||
| 1827 | ) | ||
| 1828 | | | ||
| 1829 | ( | ||
| 1830 | ( | ||
| 1831 | lv_reflexiveTransitiveClosure_2_0=RULE_REFLEXIVE_TRANSITIVE_CLOSURE | ||
| 1832 | { | ||
| 1833 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); | ||
| 1834 | } | ||
| 1835 | { | ||
| 1836 | if ($current==null) { | ||
| 1837 | $current = createModelElement(grammarAccess.getCallRule()); | ||
| 1838 | } | ||
| 1839 | setWithLastConsumed( | ||
| 1840 | $current, | ||
| 1841 | "reflexiveTransitiveClosure", | ||
| 1842 | true, | ||
| 1843 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
| 1844 | } | ||
| 1845 | ) | ||
| 1846 | ) | ||
| 1847 | )? | ||
| 1848 | ( | ||
| 1849 | ( | ||
| 1850 | { | ||
| 1851 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
| 1852 | } | ||
| 1853 | lv_argumentList_3_0=ruleArgumentList | ||
| 1854 | { | ||
| 1855 | if ($current==null) { | ||
| 1856 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 1857 | } | ||
| 1858 | set( | ||
| 1859 | $current, | ||
| 1860 | "argumentList", | ||
| 1861 | lv_argumentList_3_0, | ||
| 1862 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 1863 | afterParserOrEnumRuleCall(); | ||
| 1864 | } | ||
| 1865 | ) | ||
| 1866 | ) | ||
| 1867 | ) | ||
| 1868 | ; | ||
| 1869 | |||
| 1870 | // Entry rule entryRuleArgumentList | ||
| 1871 | entryRuleArgumentList returns [EObject current=null]: | ||
| 1872 | { newCompositeNode(grammarAccess.getArgumentListRule()); } | ||
| 1873 | iv_ruleArgumentList=ruleArgumentList | ||
| 1874 | { $current=$iv_ruleArgumentList.current; } | ||
| 1875 | EOF; | ||
| 1876 | |||
| 1877 | // Rule ArgumentList | ||
| 1878 | ruleArgumentList returns [EObject current=null] | ||
| 1879 | @init { | ||
| 1880 | enterRule(); | ||
| 1881 | } | ||
| 1882 | @after { | ||
| 1883 | leaveRule(); | ||
| 1884 | }: | ||
| 1885 | ( | ||
| 1886 | ( | ||
| 1887 | { | ||
| 1888 | $current = forceCreateModelElement( | ||
| 1889 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | ||
| 1890 | $current); | ||
| 1891 | } | ||
| 1892 | ) | ||
| 1893 | otherlv_1=LeftParenthesis | ||
| 1894 | { | ||
| 1895 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
| 1896 | } | ||
| 1897 | ( | ||
| 1898 | ( | ||
| 1899 | ( | ||
| 1900 | { | ||
| 1901 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
| 1902 | } | ||
| 1903 | lv_arguments_2_0=ruleArgument | ||
| 1904 | { | ||
| 1905 | if ($current==null) { | ||
| 1906 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 1907 | } | ||
| 1908 | add( | ||
| 1909 | $current, | ||
| 1910 | "arguments", | ||
| 1911 | lv_arguments_2_0, | ||
| 1912 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 1913 | afterParserOrEnumRuleCall(); | ||
| 1914 | } | ||
| 1915 | ) | ||
| 1916 | ) | ||
| 1917 | ( | ||
| 1918 | otherlv_3=Comma | ||
| 1919 | { | ||
| 1920 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
| 1921 | } | ||
| 1922 | ( | ||
| 1923 | ( | ||
| 1924 | { | ||
| 1925 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
| 1926 | } | ||
| 1927 | lv_arguments_4_0=ruleArgument | ||
| 1928 | { | ||
| 1929 | if ($current==null) { | ||
| 1930 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 1931 | } | ||
| 1932 | add( | ||
| 1933 | $current, | ||
| 1934 | "arguments", | ||
| 1935 | lv_arguments_4_0, | ||
| 1936 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 1937 | afterParserOrEnumRuleCall(); | ||
| 1938 | } | ||
| 1939 | ) | ||
| 1940 | ) | ||
| 1941 | )* | ||
| 1942 | )? | ||
| 1943 | otherlv_5=RightParenthesis | ||
| 1944 | { | ||
| 1945 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
| 1946 | } | ||
| 1947 | ) | ||
| 1948 | ; | ||
| 1949 | |||
| 1950 | // Entry rule entryRuleArgument | ||
| 1951 | entryRuleArgument returns [EObject current=null]: | ||
| 1952 | { newCompositeNode(grammarAccess.getArgumentRule()); } | ||
| 1953 | iv_ruleArgument=ruleArgument | ||
| 1954 | { $current=$iv_ruleArgument.current; } | ||
| 1955 | EOF; | ||
| 1956 | |||
| 1957 | // Rule Argument | ||
| 1958 | ruleArgument returns [EObject current=null] | ||
| 1959 | @init { | ||
| 1960 | enterRule(); | ||
| 1961 | } | ||
| 1962 | @after { | ||
| 1963 | leaveRule(); | ||
| 1964 | }: | ||
| 1965 | ( | ||
| 1966 | { | ||
| 1967 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
| 1968 | } | ||
| 1969 | this_ExpressionArgument_0=ruleExpressionArgument | ||
| 1970 | { | ||
| 1971 | $current = $this_ExpressionArgument_0.current; | ||
| 1972 | afterParserOrEnumRuleCall(); | ||
| 1973 | } | ||
| 1974 | | | ||
| 1975 | { | ||
| 1976 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
| 1977 | } | ||
| 1978 | this_StarArgument_1=ruleStarArgument | ||
| 1979 | { | ||
| 1980 | $current = $this_StarArgument_1.current; | ||
| 1981 | afterParserOrEnumRuleCall(); | ||
| 1982 | } | ||
| 1983 | | | ||
| 1984 | { | ||
| 1985 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | ||
| 1986 | } | ||
| 1987 | this_TypedArgument_2=ruleTypedArgument | ||
| 1988 | { | ||
| 1989 | $current = $this_TypedArgument_2.current; | ||
| 1990 | afterParserOrEnumRuleCall(); | ||
| 1991 | } | ||
| 1992 | | | ||
| 1993 | { | ||
| 1994 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
| 1995 | } | ||
| 1996 | this_TypedStarArgument_3=ruleTypedStarArgument | ||
| 1997 | { | ||
| 1998 | $current = $this_TypedStarArgument_3.current; | ||
| 1999 | afterParserOrEnumRuleCall(); | ||
| 2000 | } | ||
| 2001 | ) | ||
| 2002 | ; | ||
| 2003 | |||
| 2004 | // Entry rule entryRuleExpressionArgument | ||
| 2005 | entryRuleExpressionArgument returns [EObject current=null]: | ||
| 2006 | { newCompositeNode(grammarAccess.getExpressionArgumentRule()); } | ||
| 2007 | iv_ruleExpressionArgument=ruleExpressionArgument | ||
| 2008 | { $current=$iv_ruleExpressionArgument.current; } | ||
| 2009 | EOF; | ||
| 2010 | |||
| 2011 | // Rule ExpressionArgument | ||
| 2012 | ruleExpressionArgument returns [EObject current=null] | ||
| 2013 | @init { | ||
| 2014 | enterRule(); | ||
| 2015 | } | ||
| 2016 | @after { | ||
| 2017 | leaveRule(); | ||
| 2018 | }: | ||
| 2019 | ( | ||
| 2020 | ( | ||
| 2021 | { | ||
| 2022 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); | ||
| 2023 | } | ||
| 2024 | lv_body_0_0=ruleComparisonExpression | ||
| 2025 | { | ||
| 2026 | if ($current==null) { | ||
| 2027 | $current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); | ||
| 2028 | } | ||
| 2029 | set( | ||
| 2030 | $current, | ||
| 2031 | "body", | ||
| 2032 | lv_body_0_0, | ||
| 2033 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 2034 | afterParserOrEnumRuleCall(); | ||
| 2035 | } | ||
| 2036 | ) | ||
| 2037 | ) | ||
| 2038 | ; | ||
| 2039 | |||
| 2040 | // Entry rule entryRuleStarArgument | ||
| 2041 | entryRuleStarArgument returns [EObject current=null]: | ||
| 2042 | { newCompositeNode(grammarAccess.getStarArgumentRule()); } | ||
| 2043 | iv_ruleStarArgument=ruleStarArgument | ||
| 2044 | { $current=$iv_ruleStarArgument.current; } | ||
| 2045 | EOF; | ||
| 2046 | |||
| 2047 | // Rule StarArgument | ||
| 2048 | ruleStarArgument returns [EObject current=null] | ||
| 2049 | @init { | ||
| 2050 | enterRule(); | ||
| 2051 | } | ||
| 2052 | @after { | ||
| 2053 | leaveRule(); | ||
| 2054 | }: | ||
| 2055 | ( | ||
| 2056 | ( | ||
| 2057 | { | ||
| 2058 | $current = forceCreateModelElement( | ||
| 2059 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | ||
| 2060 | $current); | ||
| 2061 | } | ||
| 2062 | ) | ||
| 2063 | otherlv_1=Asterisk | ||
| 2064 | { | ||
| 2065 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
| 2066 | } | ||
| 2067 | ) | ||
| 2068 | ; | ||
| 2069 | |||
| 2070 | // Entry rule entryRuleTypedArgument | ||
| 2071 | entryRuleTypedArgument returns [EObject current=null]: | ||
| 2072 | { newCompositeNode(grammarAccess.getTypedArgumentRule()); } | ||
| 2073 | iv_ruleTypedArgument=ruleTypedArgument | ||
| 2074 | { $current=$iv_ruleTypedArgument.current; } | ||
| 2075 | EOF; | ||
| 2076 | |||
| 2077 | // Rule TypedArgument | ||
| 2078 | ruleTypedArgument returns [EObject current=null] | ||
| 2079 | @init { | ||
| 2080 | enterRule(); | ||
| 2081 | } | ||
| 2082 | @after { | ||
| 2083 | leaveRule(); | ||
| 2084 | }: | ||
| 2085 | ( | ||
| 2086 | ( | ||
| 2087 | ( | ||
| 2088 | { | ||
| 2089 | if ($current==null) { | ||
| 2090 | $current = createModelElement(grammarAccess.getTypedArgumentRule()); | ||
| 2091 | } | ||
| 2092 | } | ||
| 2093 | { | ||
| 2094 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
| 2095 | } | ||
| 2096 | ruleQualifiedName | ||
| 2097 | { | ||
| 2098 | afterParserOrEnumRuleCall(); | ||
| 2099 | } | ||
| 2100 | ) | ||
| 2101 | ) | ||
| 2102 | ( | ||
| 2103 | ( | ||
| 2104 | { | ||
| 2105 | if ($current==null) { | ||
| 2106 | $current = createModelElement(grammarAccess.getTypedArgumentRule()); | ||
| 2107 | } | ||
| 2108 | } | ||
| 2109 | { | ||
| 2110 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | ||
| 2111 | } | ||
| 2112 | ruleQualifiedName | ||
| 2113 | { | ||
| 2114 | afterParserOrEnumRuleCall(); | ||
| 2115 | } | ||
| 2116 | ) | ||
| 2117 | ) | ||
| 2118 | ) | ||
| 2119 | ; | ||
| 2120 | |||
| 2121 | // Entry rule entryRuleTypedStarArgument | ||
| 2122 | entryRuleTypedStarArgument returns [EObject current=null]: | ||
| 2123 | { newCompositeNode(grammarAccess.getTypedStarArgumentRule()); } | ||
| 2124 | iv_ruleTypedStarArgument=ruleTypedStarArgument | ||
| 2125 | { $current=$iv_ruleTypedStarArgument.current; } | ||
| 2126 | EOF; | ||
| 2127 | |||
| 2128 | // Rule TypedStarArgument | ||
| 2129 | ruleTypedStarArgument returns [EObject current=null] | ||
| 2130 | @init { | ||
| 2131 | enterRule(); | ||
| 2132 | } | ||
| 2133 | @after { | ||
| 2134 | leaveRule(); | ||
| 2135 | }: | ||
| 2136 | ( | ||
| 2137 | ( | ||
| 2138 | ( | ||
| 2139 | { | ||
| 2140 | if ($current==null) { | ||
| 2141 | $current = createModelElement(grammarAccess.getTypedStarArgumentRule()); | ||
| 2142 | } | ||
| 2143 | } | ||
| 2144 | { | ||
| 2145 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
| 2146 | } | ||
| 2147 | ruleQualifiedName | ||
| 2148 | { | ||
| 2149 | afterParserOrEnumRuleCall(); | ||
| 2150 | } | ||
| 2151 | ) | ||
| 2152 | ) | ||
| 2153 | otherlv_1=Asterisk | ||
| 2154 | { | ||
| 2155 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | ||
| 2156 | } | ||
| 2157 | ) | ||
| 2158 | ; | ||
| 2159 | |||
| 2160 | // Entry rule entryRuleReference | ||
| 2161 | entryRuleReference returns [EObject current=null]: | ||
| 2162 | { newCompositeNode(grammarAccess.getReferenceRule()); } | ||
| 2163 | iv_ruleReference=ruleReference | ||
| 2164 | { $current=$iv_ruleReference.current; } | ||
| 2165 | EOF; | ||
| 2166 | |||
| 2167 | // Rule Reference | ||
| 2168 | ruleReference returns [EObject current=null] | ||
| 2169 | @init { | ||
| 2170 | enterRule(); | ||
| 2171 | } | ||
| 2172 | @after { | ||
| 2173 | leaveRule(); | ||
| 2174 | }: | ||
| 2175 | ( | ||
| 2176 | ( | ||
| 2177 | { | ||
| 2178 | if ($current==null) { | ||
| 2179 | $current = createModelElement(grammarAccess.getReferenceRule()); | ||
| 2180 | } | ||
| 2181 | } | ||
| 2182 | { | ||
| 2183 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | ||
| 2184 | } | ||
| 2185 | ruleQualifiedName | ||
| 2186 | { | ||
| 2187 | afterParserOrEnumRuleCall(); | ||
| 2188 | } | ||
| 2189 | ) | ||
| 2190 | ) | ||
| 2191 | ; | ||
| 2192 | |||
| 2193 | // Entry rule entryRuleInterval | ||
| 2194 | entryRuleInterval returns [EObject current=null]: | ||
| 2195 | { newCompositeNode(grammarAccess.getIntervalRule()); } | ||
| 2196 | iv_ruleInterval=ruleInterval | ||
| 2197 | { $current=$iv_ruleInterval.current; } | ||
| 2198 | EOF; | ||
| 2199 | |||
| 2200 | // Rule Interval | ||
| 2201 | ruleInterval returns [EObject current=null] | ||
| 2202 | @init { | ||
| 2203 | enterRule(); | ||
| 2204 | } | ||
| 2205 | @after { | ||
| 2206 | leaveRule(); | ||
| 2207 | }: | ||
| 2208 | ( | ||
| 2209 | otherlv_0=LeftSquareBracket | ||
| 2210 | { | ||
| 2211 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
| 2212 | } | ||
| 2213 | ( | ||
| 2214 | ( | ||
| 2215 | { | ||
| 2216 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); | ||
| 2217 | } | ||
| 2218 | lv_lowerBound_1_0=ruleExpression | ||
| 2219 | { | ||
| 2220 | if ($current==null) { | ||
| 2221 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 2222 | } | ||
| 2223 | set( | ||
| 2224 | $current, | ||
| 2225 | "lowerBound", | ||
| 2226 | lv_lowerBound_1_0, | ||
| 2227 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2228 | afterParserOrEnumRuleCall(); | ||
| 2229 | } | ||
| 2230 | ) | ||
| 2231 | ) | ||
| 2232 | otherlv_2=FullStopFullStop | ||
| 2233 | { | ||
| 2234 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | ||
| 2235 | } | ||
| 2236 | ( | ||
| 2237 | ( | ||
| 2238 | { | ||
| 2239 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | ||
| 2240 | } | ||
| 2241 | lv_upperBound_3_0=ruleExpression | ||
| 2242 | { | ||
| 2243 | if ($current==null) { | ||
| 2244 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 2245 | } | ||
| 2246 | set( | ||
| 2247 | $current, | ||
| 2248 | "upperBound", | ||
| 2249 | lv_upperBound_3_0, | ||
| 2250 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2251 | afterParserOrEnumRuleCall(); | ||
| 2252 | } | ||
| 2253 | ) | ||
| 2254 | ) | ||
| 2255 | otherlv_4=RightSquareBracket | ||
| 2256 | { | ||
| 2257 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
| 2258 | } | ||
| 2259 | ) | ||
| 2260 | ; | ||
| 2261 | |||
| 2262 | // Entry rule entryRuleLiteral | ||
| 2263 | entryRuleLiteral returns [EObject current=null]: | ||
| 2264 | { newCompositeNode(grammarAccess.getLiteralRule()); } | ||
| 2265 | iv_ruleLiteral=ruleLiteral | ||
| 2266 | { $current=$iv_ruleLiteral.current; } | ||
| 2267 | EOF; | ||
| 2268 | |||
| 2269 | // Rule Literal | ||
| 2270 | ruleLiteral returns [EObject current=null] | ||
| 2271 | @init { | ||
| 2272 | enterRule(); | ||
| 2273 | } | ||
| 2274 | @after { | ||
| 2275 | leaveRule(); | ||
| 2276 | }: | ||
| 2277 | ( | ||
| 2278 | { | ||
| 2279 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
| 2280 | } | ||
| 2281 | this_LogicLiteral_0=ruleLogicLiteral | ||
| 2282 | { | ||
| 2283 | $current = $this_LogicLiteral_0.current; | ||
| 2284 | afterParserOrEnumRuleCall(); | ||
| 2285 | } | ||
| 2286 | | | ||
| 2287 | { | ||
| 2288 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | ||
| 2289 | } | ||
| 2290 | this_NumericLiteral_1=ruleNumericLiteral | ||
| 2291 | { | ||
| 2292 | $current = $this_NumericLiteral_1.current; | ||
| 2293 | afterParserOrEnumRuleCall(); | ||
| 2294 | } | ||
| 2295 | | | ||
| 2296 | { | ||
| 2297 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | ||
| 2298 | } | ||
| 2299 | this_InfinityLiteral_2=ruleInfinityLiteral | ||
| 2300 | { | ||
| 2301 | $current = $this_InfinityLiteral_2.current; | ||
| 2302 | afterParserOrEnumRuleCall(); | ||
| 2303 | } | ||
| 2304 | | | ||
| 2305 | { | ||
| 2306 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); | ||
| 2307 | } | ||
| 2308 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral | ||
| 2309 | { | ||
| 2310 | $current = $this_EmptyIntervalLiteral_3.current; | ||
| 2311 | afterParserOrEnumRuleCall(); | ||
| 2312 | } | ||
| 2313 | | | ||
| 2314 | { | ||
| 2315 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); | ||
| 2316 | } | ||
| 2317 | this_StringLiteral_4=ruleStringLiteral | ||
| 2318 | { | ||
| 2319 | $current = $this_StringLiteral_4.current; | ||
| 2320 | afterParserOrEnumRuleCall(); | ||
| 2321 | } | ||
| 2322 | ) | ||
| 2323 | ; | ||
| 2324 | |||
| 2325 | // Entry rule entryRuleLogicLiteral | ||
| 2326 | entryRuleLogicLiteral returns [EObject current=null]: | ||
| 2327 | { newCompositeNode(grammarAccess.getLogicLiteralRule()); } | ||
| 2328 | iv_ruleLogicLiteral=ruleLogicLiteral | ||
| 2329 | { $current=$iv_ruleLogicLiteral.current; } | ||
| 2330 | EOF; | ||
| 2331 | |||
| 2332 | // Rule LogicLiteral | ||
| 2333 | ruleLogicLiteral returns [EObject current=null] | ||
| 2334 | @init { | ||
| 2335 | enterRule(); | ||
| 2336 | } | ||
| 2337 | @after { | ||
| 2338 | leaveRule(); | ||
| 2339 | }: | ||
| 2340 | ( | ||
| 2341 | ( | ||
| 2342 | { | ||
| 2343 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | ||
| 2344 | } | ||
| 2345 | lv_value_0_0=ruleLogicValue | ||
| 2346 | { | ||
| 2347 | if ($current==null) { | ||
| 2348 | $current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | ||
| 2349 | } | ||
| 2350 | set( | ||
| 2351 | $current, | ||
| 2352 | "value", | ||
| 2353 | lv_value_0_0, | ||
| 2354 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
| 2355 | afterParserOrEnumRuleCall(); | ||
| 2356 | } | ||
| 2357 | ) | ||
| 2358 | ) | ||
| 2359 | ; | ||
| 2360 | |||
| 2361 | // Entry rule entryRuleNumericLiteral | ||
| 2362 | entryRuleNumericLiteral returns [EObject current=null]: | ||
| 2363 | { newCompositeNode(grammarAccess.getNumericLiteralRule()); } | ||
| 2364 | iv_ruleNumericLiteral=ruleNumericLiteral | ||
| 2365 | { $current=$iv_ruleNumericLiteral.current; } | ||
| 2366 | EOF; | ||
| 2367 | |||
| 2368 | // Rule NumericLiteral | ||
| 2369 | ruleNumericLiteral returns [EObject current=null] | ||
| 2370 | @init { | ||
| 2371 | enterRule(); | ||
| 2372 | } | ||
| 2373 | @after { | ||
| 2374 | leaveRule(); | ||
| 2375 | }: | ||
| 2376 | ( | ||
| 2377 | ( | ||
| 2378 | { | ||
| 2379 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | ||
| 2380 | } | ||
| 2381 | lv_value_0_0=ruleReal | ||
| 2382 | { | ||
| 2383 | if ($current==null) { | ||
| 2384 | $current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); | ||
| 2385 | } | ||
| 2386 | set( | ||
| 2387 | $current, | ||
| 2388 | "value", | ||
| 2389 | lv_value_0_0, | ||
| 2390 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
| 2391 | afterParserOrEnumRuleCall(); | ||
| 2392 | } | ||
| 2393 | ) | ||
| 2394 | ) | ||
| 2395 | ; | ||
| 2396 | |||
| 2397 | // Entry rule entryRuleInfinityLiteral | ||
| 2398 | entryRuleInfinityLiteral returns [EObject current=null]: | ||
| 2399 | { newCompositeNode(grammarAccess.getInfinityLiteralRule()); } | ||
| 2400 | iv_ruleInfinityLiteral=ruleInfinityLiteral | ||
| 2401 | { $current=$iv_ruleInfinityLiteral.current; } | ||
| 2402 | EOF; | ||
| 2403 | |||
| 2404 | // Rule InfinityLiteral | ||
| 2405 | ruleInfinityLiteral returns [EObject current=null] | ||
| 2406 | @init { | ||
| 2407 | enterRule(); | ||
| 2408 | } | ||
| 2409 | @after { | ||
| 2410 | leaveRule(); | ||
| 2411 | }: | ||
| 2412 | ( | ||
| 2413 | ( | ||
| 2414 | { | ||
| 2415 | $current = forceCreateModelElement( | ||
| 2416 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
| 2417 | $current); | ||
| 2418 | } | ||
| 2419 | ) | ||
| 2420 | otherlv_1=Inf | ||
| 2421 | { | ||
| 2422 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | ||
| 2423 | } | ||
| 2424 | ) | ||
| 2425 | ; | ||
| 2426 | |||
| 2427 | // Entry rule entryRuleEmptyIntervalLiteral | ||
| 2428 | entryRuleEmptyIntervalLiteral returns [EObject current=null]: | ||
| 2429 | { newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); } | ||
| 2430 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral | ||
| 2431 | { $current=$iv_ruleEmptyIntervalLiteral.current; } | ||
| 2432 | EOF; | ||
| 2433 | |||
| 2434 | // Rule EmptyIntervalLiteral | ||
| 2435 | ruleEmptyIntervalLiteral returns [EObject current=null] | ||
| 2436 | @init { | ||
| 2437 | enterRule(); | ||
| 2438 | } | ||
| 2439 | @after { | ||
| 2440 | leaveRule(); | ||
| 2441 | }: | ||
| 2442 | ( | ||
| 2443 | ( | ||
| 2444 | { | ||
| 2445 | $current = forceCreateModelElement( | ||
| 2446 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), | ||
| 2447 | $current); | ||
| 2448 | } | ||
| 2449 | ) | ||
| 2450 | otherlv_1=Empty | ||
| 2451 | { | ||
| 2452 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | ||
| 2453 | } | ||
| 2454 | ) | ||
| 2455 | ; | ||
| 2456 | |||
| 2457 | // Entry rule entryRuleStringLiteral | ||
| 2458 | entryRuleStringLiteral returns [EObject current=null]: | ||
| 2459 | { newCompositeNode(grammarAccess.getStringLiteralRule()); } | ||
| 2460 | iv_ruleStringLiteral=ruleStringLiteral | ||
| 2461 | { $current=$iv_ruleStringLiteral.current; } | ||
| 2462 | EOF; | ||
| 2463 | |||
| 2464 | // Rule StringLiteral | ||
| 2465 | ruleStringLiteral returns [EObject current=null] | ||
| 2466 | @init { | ||
| 2467 | enterRule(); | ||
| 2468 | } | ||
| 2469 | @after { | ||
| 2470 | leaveRule(); | ||
| 2471 | }: | ||
| 2472 | ( | ||
| 2473 | ( | ||
| 2474 | lv_value_0_0=RULE_STRING | ||
| 2475 | { | ||
| 2476 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | ||
| 2477 | } | ||
| 2478 | { | ||
| 2479 | if ($current==null) { | ||
| 2480 | $current = createModelElement(grammarAccess.getStringLiteralRule()); | ||
| 2481 | } | ||
| 2482 | setWithLastConsumed( | ||
| 2483 | $current, | ||
| 2484 | "value", | ||
| 2485 | lv_value_0_0, | ||
| 2486 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 2487 | } | ||
| 2488 | ) | ||
| 2489 | ) | ||
| 2490 | ; | ||
| 2491 | |||
| 2492 | // Entry rule entryRuleClassDefinition | ||
| 2493 | entryRuleClassDefinition returns [EObject current=null]: | ||
| 2494 | { newCompositeNode(grammarAccess.getClassDefinitionRule()); } | ||
| 2495 | iv_ruleClassDefinition=ruleClassDefinition | ||
| 2496 | { $current=$iv_ruleClassDefinition.current; } | ||
| 2497 | EOF; | ||
| 2498 | |||
| 2499 | // Rule ClassDefinition | ||
| 2500 | ruleClassDefinition returns [EObject current=null] | ||
| 2501 | @init { | ||
| 2502 | enterRule(); | ||
| 2503 | } | ||
| 2504 | @after { | ||
| 2505 | leaveRule(); | ||
| 2506 | }: | ||
| 2507 | ( | ||
| 2508 | ( | ||
| 2509 | ( | ||
| 2510 | lv_abstract_0_0=Abstract | ||
| 2511 | { | ||
| 2512 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | ||
| 2513 | } | ||
| 2514 | { | ||
| 2515 | if ($current==null) { | ||
| 2516 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 2517 | } | ||
| 2518 | setWithLastConsumed($current, "abstract", true, "abstract"); | ||
| 2519 | } | ||
| 2520 | ) | ||
| 2521 | )? | ||
| 2522 | otherlv_1=Class | ||
| 2523 | { | ||
| 2524 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | ||
| 2525 | } | ||
| 2526 | ( | ||
| 2527 | ( | ||
| 2528 | lv_name_2_0=RULE_ID | ||
| 2529 | { | ||
| 2530 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); | ||
| 2531 | } | ||
| 2532 | { | ||
| 2533 | if ($current==null) { | ||
| 2534 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 2535 | } | ||
| 2536 | setWithLastConsumed( | ||
| 2537 | $current, | ||
| 2538 | "name", | ||
| 2539 | lv_name_2_0, | ||
| 2540 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 2541 | } | ||
| 2542 | ) | ||
| 2543 | ) | ||
| 2544 | ( | ||
| 2545 | otherlv_3=Extends | ||
| 2546 | { | ||
| 2547 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); | ||
| 2548 | } | ||
| 2549 | ( | ||
| 2550 | ( | ||
| 2551 | { | ||
| 2552 | if ($current==null) { | ||
| 2553 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 2554 | } | ||
| 2555 | } | ||
| 2556 | { | ||
| 2557 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | ||
| 2558 | } | ||
| 2559 | ruleQualifiedName | ||
| 2560 | { | ||
| 2561 | afterParserOrEnumRuleCall(); | ||
| 2562 | } | ||
| 2563 | ) | ||
| 2564 | ) | ||
| 2565 | ( | ||
| 2566 | otherlv_5=Comma | ||
| 2567 | { | ||
| 2568 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | ||
| 2569 | } | ||
| 2570 | ( | ||
| 2571 | ( | ||
| 2572 | { | ||
| 2573 | if ($current==null) { | ||
| 2574 | $current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 2575 | } | ||
| 2576 | } | ||
| 2577 | { | ||
| 2578 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | ||
| 2579 | } | ||
| 2580 | ruleQualifiedName | ||
| 2581 | { | ||
| 2582 | afterParserOrEnumRuleCall(); | ||
| 2583 | } | ||
| 2584 | ) | ||
| 2585 | ) | ||
| 2586 | )* | ||
| 2587 | )? | ||
| 2588 | otherlv_7=LeftCurlyBracket | ||
| 2589 | { | ||
| 2590 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | ||
| 2591 | } | ||
| 2592 | ( | ||
| 2593 | ( | ||
| 2594 | { | ||
| 2595 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
| 2596 | } | ||
| 2597 | lv_members_8_0=ruleMemberDefinition | ||
| 2598 | { | ||
| 2599 | if ($current==null) { | ||
| 2600 | $current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); | ||
| 2601 | } | ||
| 2602 | add( | ||
| 2603 | $current, | ||
| 2604 | "members", | ||
| 2605 | lv_members_8_0, | ||
| 2606 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); | ||
| 2607 | afterParserOrEnumRuleCall(); | ||
| 2608 | } | ||
| 2609 | ) | ||
| 2610 | )* | ||
| 2611 | otherlv_9=RightCurlyBracket | ||
| 2612 | { | ||
| 2613 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | ||
| 2614 | } | ||
| 2615 | ) | ||
| 2616 | ; | ||
| 2617 | |||
| 2618 | // Entry rule entryRuleMemberDefinition | ||
| 2619 | entryRuleMemberDefinition returns [EObject current=null]: | ||
| 2620 | { newCompositeNode(grammarAccess.getMemberDefinitionRule()); } | ||
| 2621 | iv_ruleMemberDefinition=ruleMemberDefinition | ||
| 2622 | { $current=$iv_ruleMemberDefinition.current; } | ||
| 2623 | EOF; | ||
| 2624 | |||
| 2625 | // Rule MemberDefinition | ||
| 2626 | ruleMemberDefinition returns [EObject current=null] | ||
| 2627 | @init { | ||
| 2628 | enterRule(); | ||
| 2629 | } | ||
| 2630 | @after { | ||
| 2631 | leaveRule(); | ||
| 2632 | }: | ||
| 2633 | ( | ||
| 2634 | ( | ||
| 2635 | ( | ||
| 2636 | lv_containment_0_0=Contains | ||
| 2637 | { | ||
| 2638 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
| 2639 | } | ||
| 2640 | { | ||
| 2641 | if ($current==null) { | ||
| 2642 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2643 | } | ||
| 2644 | setWithLastConsumed($current, "containment", true, "contains"); | ||
| 2645 | } | ||
| 2646 | ) | ||
| 2647 | )? | ||
| 2648 | ( | ||
| 2649 | ( | ||
| 2650 | { | ||
| 2651 | if ($current==null) { | ||
| 2652 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2653 | } | ||
| 2654 | } | ||
| 2655 | { | ||
| 2656 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 2657 | } | ||
| 2658 | ruleQualifiedName | ||
| 2659 | { | ||
| 2660 | afterParserOrEnumRuleCall(); | ||
| 2661 | } | ||
| 2662 | ) | ||
| 2663 | ) | ||
| 2664 | ( | ||
| 2665 | ( | ||
| 2666 | { | ||
| 2667 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
| 2668 | } | ||
| 2669 | lv_multiplicity_2_0=ruleMultiplicity | ||
| 2670 | { | ||
| 2671 | if ($current==null) { | ||
| 2672 | $current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); | ||
| 2673 | } | ||
| 2674 | set( | ||
| 2675 | $current, | ||
| 2676 | "multiplicity", | ||
| 2677 | lv_multiplicity_2_0, | ||
| 2678 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
| 2679 | afterParserOrEnumRuleCall(); | ||
| 2680 | } | ||
| 2681 | ) | ||
| 2682 | )? | ||
| 2683 | ( | ||
| 2684 | ( | ||
| 2685 | lv_name_3_0=RULE_ID | ||
| 2686 | { | ||
| 2687 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | ||
| 2688 | } | ||
| 2689 | { | ||
| 2690 | if ($current==null) { | ||
| 2691 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2692 | } | ||
| 2693 | setWithLastConsumed( | ||
| 2694 | $current, | ||
| 2695 | "name", | ||
| 2696 | lv_name_3_0, | ||
| 2697 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 2698 | } | ||
| 2699 | ) | ||
| 2700 | ) | ||
| 2701 | ( | ||
| 2702 | otherlv_4=Opposite | ||
| 2703 | { | ||
| 2704 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | ||
| 2705 | } | ||
| 2706 | ( | ||
| 2707 | ( | ||
| 2708 | { | ||
| 2709 | if ($current==null) { | ||
| 2710 | $current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 2711 | } | ||
| 2712 | } | ||
| 2713 | { | ||
| 2714 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | ||
| 2715 | } | ||
| 2716 | ruleQualifiedName | ||
| 2717 | { | ||
| 2718 | afterParserOrEnumRuleCall(); | ||
| 2719 | } | ||
| 2720 | ) | ||
| 2721 | ) | ||
| 2722 | )? | ||
| 2723 | ( | ||
| 2724 | otherlv_6=Semicolon | ||
| 2725 | { | ||
| 2726 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | ||
| 2727 | } | ||
| 2728 | )? | ||
| 2729 | ) | ||
| 2730 | ; | ||
| 2731 | |||
| 2732 | // Entry rule entryRuleMultiplicity | ||
| 2733 | entryRuleMultiplicity returns [EObject current=null]: | ||
| 2734 | { newCompositeNode(grammarAccess.getMultiplicityRule()); } | ||
| 2735 | iv_ruleMultiplicity=ruleMultiplicity | ||
| 2736 | { $current=$iv_ruleMultiplicity.current; } | ||
| 2737 | EOF; | ||
| 2738 | |||
| 2739 | // Rule Multiplicity | ||
| 2740 | ruleMultiplicity returns [EObject current=null] | ||
| 2741 | @init { | ||
| 2742 | enterRule(); | ||
| 2743 | } | ||
| 2744 | @after { | ||
| 2745 | leaveRule(); | ||
| 2746 | }: | ||
| 2747 | ( | ||
| 2748 | { | ||
| 2749 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); | ||
| 2750 | } | ||
| 2751 | this_ManyMultiplicity_0=ruleManyMultiplicity | ||
| 2752 | { | ||
| 2753 | $current = $this_ManyMultiplicity_0.current; | ||
| 2754 | afterParserOrEnumRuleCall(); | ||
| 2755 | } | ||
| 2756 | | | ||
| 2757 | { | ||
| 2758 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
| 2759 | } | ||
| 2760 | this_ExactMultiplicity_1=ruleExactMultiplicity | ||
| 2761 | { | ||
| 2762 | $current = $this_ExactMultiplicity_1.current; | ||
| 2763 | afterParserOrEnumRuleCall(); | ||
| 2764 | } | ||
| 2765 | | | ||
| 2766 | { | ||
| 2767 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
| 2768 | } | ||
| 2769 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity | ||
| 2770 | { | ||
| 2771 | $current = $this_BoundedMultiplicity_2.current; | ||
| 2772 | afterParserOrEnumRuleCall(); | ||
| 2773 | } | ||
| 2774 | ) | ||
| 2775 | ; | ||
| 2776 | |||
| 2777 | // Entry rule entryRuleManyMultiplicity | ||
| 2778 | entryRuleManyMultiplicity returns [EObject current=null]: | ||
| 2779 | { newCompositeNode(grammarAccess.getManyMultiplicityRule()); } | ||
| 2780 | iv_ruleManyMultiplicity=ruleManyMultiplicity | ||
| 2781 | { $current=$iv_ruleManyMultiplicity.current; } | ||
| 2782 | EOF; | ||
| 2783 | |||
| 2784 | // Rule ManyMultiplicity | ||
| 2785 | ruleManyMultiplicity returns [EObject current=null] | ||
| 2786 | @init { | ||
| 2787 | enterRule(); | ||
| 2788 | } | ||
| 2789 | @after { | ||
| 2790 | leaveRule(); | ||
| 2791 | }: | ||
| 2792 | ( | ||
| 2793 | ( | ||
| 2794 | { | ||
| 2795 | $current = forceCreateModelElement( | ||
| 2796 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), | ||
| 2797 | $current); | ||
| 2798 | } | ||
| 2799 | ) | ||
| 2800 | otherlv_1=LeftSquareBracket | ||
| 2801 | { | ||
| 2802 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
| 2803 | } | ||
| 2804 | otherlv_2=RightSquareBracket | ||
| 2805 | { | ||
| 2806 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 2807 | } | ||
| 2808 | ) | ||
| 2809 | ; | ||
| 2810 | |||
| 2811 | // Entry rule entryRuleExactMultiplicity | ||
| 2812 | entryRuleExactMultiplicity returns [EObject current=null]: | ||
| 2813 | { newCompositeNode(grammarAccess.getExactMultiplicityRule()); } | ||
| 2814 | iv_ruleExactMultiplicity=ruleExactMultiplicity | ||
| 2815 | { $current=$iv_ruleExactMultiplicity.current; } | ||
| 2816 | EOF; | ||
| 2817 | |||
| 2818 | // Rule ExactMultiplicity | ||
| 2819 | ruleExactMultiplicity returns [EObject current=null] | ||
| 2820 | @init { | ||
| 2821 | enterRule(); | ||
| 2822 | } | ||
| 2823 | @after { | ||
| 2824 | leaveRule(); | ||
| 2825 | }: | ||
| 2826 | ( | ||
| 2827 | otherlv_0=LeftSquareBracket | ||
| 2828 | { | ||
| 2829 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 2830 | } | ||
| 2831 | ( | ||
| 2832 | ( | ||
| 2833 | { | ||
| 2834 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); | ||
| 2835 | } | ||
| 2836 | lv_multiplicity_1_0=ruleUpperMultiplicty | ||
| 2837 | { | ||
| 2838 | if ($current==null) { | ||
| 2839 | $current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); | ||
| 2840 | } | ||
| 2841 | set( | ||
| 2842 | $current, | ||
| 2843 | "multiplicity", | ||
| 2844 | lv_multiplicity_1_0, | ||
| 2845 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 2846 | afterParserOrEnumRuleCall(); | ||
| 2847 | } | ||
| 2848 | ) | ||
| 2849 | ) | ||
| 2850 | otherlv_2=RightSquareBracket | ||
| 2851 | { | ||
| 2852 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 2853 | } | ||
| 2854 | ) | ||
| 2855 | ; | ||
| 2856 | |||
| 2857 | // Entry rule entryRuleBoundedMultiplicity | ||
| 2858 | entryRuleBoundedMultiplicity returns [EObject current=null]: | ||
| 2859 | { newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); } | ||
| 2860 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity | ||
| 2861 | { $current=$iv_ruleBoundedMultiplicity.current; } | ||
| 2862 | EOF; | ||
| 2863 | |||
| 2864 | // Rule BoundedMultiplicity | ||
| 2865 | ruleBoundedMultiplicity returns [EObject current=null] | ||
| 2866 | @init { | ||
| 2867 | enterRule(); | ||
| 2868 | } | ||
| 2869 | @after { | ||
| 2870 | leaveRule(); | ||
| 2871 | }: | ||
| 2872 | ( | ||
| 2873 | otherlv_0=LeftSquareBracket | ||
| 2874 | { | ||
| 2875 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 2876 | } | ||
| 2877 | ( | ||
| 2878 | ( | ||
| 2879 | lv_lowerBound_1_0=RULE_INT | ||
| 2880 | { | ||
| 2881 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | ||
| 2882 | } | ||
| 2883 | { | ||
| 2884 | if ($current==null) { | ||
| 2885 | $current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
| 2886 | } | ||
| 2887 | setWithLastConsumed( | ||
| 2888 | $current, | ||
| 2889 | "lowerBound", | ||
| 2890 | lv_lowerBound_1_0, | ||
| 2891 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 2892 | } | ||
| 2893 | ) | ||
| 2894 | ) | ||
| 2895 | otherlv_2=FullStopFullStop | ||
| 2896 | { | ||
| 2897 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | ||
| 2898 | } | ||
| 2899 | ( | ||
| 2900 | ( | ||
| 2901 | { | ||
| 2902 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
| 2903 | } | ||
| 2904 | lv_upperBound_3_0=ruleUpperMultiplicty | ||
| 2905 | { | ||
| 2906 | if ($current==null) { | ||
| 2907 | $current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
| 2908 | } | ||
| 2909 | set( | ||
| 2910 | $current, | ||
| 2911 | "upperBound", | ||
| 2912 | lv_upperBound_3_0, | ||
| 2913 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 2914 | afterParserOrEnumRuleCall(); | ||
| 2915 | } | ||
| 2916 | ) | ||
| 2917 | ) | ||
| 2918 | otherlv_4=RightSquareBracket | ||
| 2919 | { | ||
| 2920 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
| 2921 | } | ||
| 2922 | ) | ||
| 2923 | ; | ||
| 2924 | |||
| 2925 | // Entry rule entryRuleScopeDefinition | ||
| 2926 | entryRuleScopeDefinition returns [EObject current=null]: | ||
| 2927 | { newCompositeNode(grammarAccess.getScopeDefinitionRule()); } | ||
| 2928 | iv_ruleScopeDefinition=ruleScopeDefinition | ||
| 2929 | { $current=$iv_ruleScopeDefinition.current; } | ||
| 2930 | EOF; | ||
| 2931 | |||
| 2932 | // Rule ScopeDefinition | ||
| 2933 | ruleScopeDefinition returns [EObject current=null] | ||
| 2934 | @init { | ||
| 2935 | enterRule(); | ||
| 2936 | } | ||
| 2937 | @after { | ||
| 2938 | leaveRule(); | ||
| 2939 | }: | ||
| 2940 | ( | ||
| 2941 | { | ||
| 2942 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
| 2943 | } | ||
| 2944 | this_ExactScopeDefinition_0=ruleExactScopeDefinition | ||
| 2945 | { | ||
| 2946 | $current = $this_ExactScopeDefinition_0.current; | ||
| 2947 | afterParserOrEnumRuleCall(); | ||
| 2948 | } | ||
| 2949 | | | ||
| 2950 | { | ||
| 2951 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
| 2952 | } | ||
| 2953 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition | ||
| 2954 | { | ||
| 2955 | $current = $this_BoundedScopeDefinition_1.current; | ||
| 2956 | afterParserOrEnumRuleCall(); | ||
| 2957 | } | ||
| 2958 | | | ||
| 2959 | { | ||
| 2960 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
| 2961 | } | ||
| 2962 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition | ||
| 2963 | { | ||
| 2964 | $current = $this_LowerBoundedScopeDefinition_2.current; | ||
| 2965 | afterParserOrEnumRuleCall(); | ||
| 2966 | } | ||
| 2967 | ) | ||
| 2968 | ; | ||
| 2969 | |||
| 2970 | // Entry rule entryRuleExactScopeDefinition | ||
| 2971 | entryRuleExactScopeDefinition returns [EObject current=null]: | ||
| 2972 | { newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); } | ||
| 2973 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition | ||
| 2974 | { $current=$iv_ruleExactScopeDefinition.current; } | ||
| 2975 | EOF; | ||
| 2976 | |||
| 2977 | // Rule ExactScopeDefinition | ||
| 2978 | ruleExactScopeDefinition returns [EObject current=null] | ||
| 2979 | @init { | ||
| 2980 | enterRule(); | ||
| 2981 | } | ||
| 2982 | @after { | ||
| 2983 | leaveRule(); | ||
| 2984 | }: | ||
| 2985 | ( | ||
| 2986 | otherlv_0=Scope | ||
| 2987 | { | ||
| 2988 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 2989 | } | ||
| 2990 | ( | ||
| 2991 | ( | ||
| 2992 | { | ||
| 2993 | if ($current==null) { | ||
| 2994 | $current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | ||
| 2995 | } | ||
| 2996 | } | ||
| 2997 | { | ||
| 2998 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 2999 | } | ||
| 3000 | ruleQualifiedName | ||
| 3001 | { | ||
| 3002 | afterParserOrEnumRuleCall(); | ||
| 3003 | } | ||
| 3004 | ) | ||
| 3005 | ) | ||
| 3006 | otherlv_2=EqualsSignEqualsSign | ||
| 3007 | { | ||
| 3008 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | ||
| 3009 | } | ||
| 3010 | ( | ||
| 3011 | ( | ||
| 3012 | lv_exactScope_3_0=RULE_INT | ||
| 3013 | { | ||
| 3014 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | ||
| 3015 | } | ||
| 3016 | { | ||
| 3017 | if ($current==null) { | ||
| 3018 | $current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | ||
| 3019 | } | ||
| 3020 | setWithLastConsumed( | ||
| 3021 | $current, | ||
| 3022 | "exactScope", | ||
| 3023 | lv_exactScope_3_0, | ||
| 3024 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3025 | } | ||
| 3026 | ) | ||
| 3027 | ) | ||
| 3028 | ) | ||
| 3029 | ; | ||
| 3030 | |||
| 3031 | // Entry rule entryRuleBoundedScopeDefinition | ||
| 3032 | entryRuleBoundedScopeDefinition returns [EObject current=null]: | ||
| 3033 | { newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); } | ||
| 3034 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition | ||
| 3035 | { $current=$iv_ruleBoundedScopeDefinition.current; } | ||
| 3036 | EOF; | ||
| 3037 | |||
| 3038 | // Rule BoundedScopeDefinition | ||
| 3039 | ruleBoundedScopeDefinition returns [EObject current=null] | ||
| 3040 | @init { | ||
| 3041 | enterRule(); | ||
| 3042 | } | ||
| 3043 | @after { | ||
| 3044 | leaveRule(); | ||
| 3045 | }: | ||
| 3046 | ( | ||
| 3047 | otherlv_0=Scope | ||
| 3048 | { | ||
| 3049 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 3050 | } | ||
| 3051 | ( | ||
| 3052 | ( | ||
| 3053 | ( | ||
| 3054 | ( | ||
| 3055 | ( | ||
| 3056 | lv_lowerBound_1_0=RULE_INT | ||
| 3057 | { | ||
| 3058 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
| 3059 | } | ||
| 3060 | { | ||
| 3061 | if ($current==null) { | ||
| 3062 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3063 | } | ||
| 3064 | setWithLastConsumed( | ||
| 3065 | $current, | ||
| 3066 | "lowerBound", | ||
| 3067 | lv_lowerBound_1_0, | ||
| 3068 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3069 | } | ||
| 3070 | ) | ||
| 3071 | ) | ||
| 3072 | otherlv_2=LessThanSignEqualsSign | ||
| 3073 | { | ||
| 3074 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
| 3075 | } | ||
| 3076 | )? | ||
| 3077 | ( | ||
| 3078 | ( | ||
| 3079 | { | ||
| 3080 | if ($current==null) { | ||
| 3081 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3082 | } | ||
| 3083 | } | ||
| 3084 | { | ||
| 3085 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | ||
| 3086 | } | ||
| 3087 | ruleQualifiedName | ||
| 3088 | { | ||
| 3089 | afterParserOrEnumRuleCall(); | ||
| 3090 | } | ||
| 3091 | ) | ||
| 3092 | ) | ||
| 3093 | otherlv_4=LessThanSignEqualsSign | ||
| 3094 | { | ||
| 3095 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
| 3096 | } | ||
| 3097 | ( | ||
| 3098 | ( | ||
| 3099 | lv_upperBound_5_0=RULE_INT | ||
| 3100 | { | ||
| 3101 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
| 3102 | } | ||
| 3103 | { | ||
| 3104 | if ($current==null) { | ||
| 3105 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3106 | } | ||
| 3107 | setWithLastConsumed( | ||
| 3108 | $current, | ||
| 3109 | "upperBound", | ||
| 3110 | lv_upperBound_5_0, | ||
| 3111 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3112 | } | ||
| 3113 | ) | ||
| 3114 | ) | ||
| 3115 | ) | ||
| 3116 | | | ||
| 3117 | ( | ||
| 3118 | ( | ||
| 3119 | ( | ||
| 3120 | lv_upperBound_6_0=RULE_INT | ||
| 3121 | { | ||
| 3122 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | ||
| 3123 | } | ||
| 3124 | { | ||
| 3125 | if ($current==null) { | ||
| 3126 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3127 | } | ||
| 3128 | setWithLastConsumed( | ||
| 3129 | $current, | ||
| 3130 | "upperBound", | ||
| 3131 | lv_upperBound_6_0, | ||
| 3132 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3133 | } | ||
| 3134 | ) | ||
| 3135 | ) | ||
| 3136 | otherlv_7=GreaterThanSignEqualsSign | ||
| 3137 | { | ||
| 3138 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 3139 | } | ||
| 3140 | ( | ||
| 3141 | ( | ||
| 3142 | { | ||
| 3143 | if ($current==null) { | ||
| 3144 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3145 | } | ||
| 3146 | } | ||
| 3147 | { | ||
| 3148 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
| 3149 | } | ||
| 3150 | ruleQualifiedName | ||
| 3151 | { | ||
| 3152 | afterParserOrEnumRuleCall(); | ||
| 3153 | } | ||
| 3154 | ) | ||
| 3155 | ) | ||
| 3156 | ( | ||
| 3157 | otherlv_9=GreaterThanSignEqualsSign | ||
| 3158 | { | ||
| 3159 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
| 3160 | } | ||
| 3161 | ( | ||
| 3162 | ( | ||
| 3163 | lv_lowerBound_10_0=RULE_INT | ||
| 3164 | { | ||
| 3165 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
| 3166 | } | ||
| 3167 | { | ||
| 3168 | if ($current==null) { | ||
| 3169 | $current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 3170 | } | ||
| 3171 | setWithLastConsumed( | ||
| 3172 | $current, | ||
| 3173 | "lowerBound", | ||
| 3174 | lv_lowerBound_10_0, | ||
| 3175 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3176 | } | ||
| 3177 | ) | ||
| 3178 | ) | ||
| 3179 | )? | ||
| 3180 | ) | ||
| 3181 | ) | ||
| 3182 | ) | ||
| 3183 | ; | ||
| 3184 | |||
| 3185 | // Entry rule entryRuleLowerBoundedScopeDefinition | ||
| 3186 | entryRuleLowerBoundedScopeDefinition returns [EObject current=null]: | ||
| 3187 | { newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); } | ||
| 3188 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition | ||
| 3189 | { $current=$iv_ruleLowerBoundedScopeDefinition.current; } | ||
| 3190 | EOF; | ||
| 3191 | |||
| 3192 | // Rule LowerBoundedScopeDefinition | ||
| 3193 | ruleLowerBoundedScopeDefinition returns [EObject current=null] | ||
| 3194 | @init { | ||
| 3195 | enterRule(); | ||
| 3196 | } | ||
| 3197 | @after { | ||
| 3198 | leaveRule(); | ||
| 3199 | }: | ||
| 3200 | ( | ||
| 3201 | otherlv_0=Scope | ||
| 3202 | { | ||
| 3203 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 3204 | } | ||
| 3205 | ( | ||
| 3206 | ( | ||
| 3207 | ( | ||
| 3208 | ( | ||
| 3209 | lv_lowerBound_1_0=RULE_INT | ||
| 3210 | { | ||
| 3211 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | ||
| 3212 | } | ||
| 3213 | { | ||
| 3214 | if ($current==null) { | ||
| 3215 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 3216 | } | ||
| 3217 | setWithLastConsumed( | ||
| 3218 | $current, | ||
| 3219 | "lowerBound", | ||
| 3220 | lv_lowerBound_1_0, | ||
| 3221 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3222 | } | ||
| 3223 | ) | ||
| 3224 | ) | ||
| 3225 | otherlv_2=LessThanSignEqualsSign | ||
| 3226 | { | ||
| 3227 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | ||
| 3228 | } | ||
| 3229 | ( | ||
| 3230 | ( | ||
| 3231 | { | ||
| 3232 | if ($current==null) { | ||
| 3233 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 3234 | } | ||
| 3235 | } | ||
| 3236 | { | ||
| 3237 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | ||
| 3238 | } | ||
| 3239 | ruleQualifiedName | ||
| 3240 | { | ||
| 3241 | afterParserOrEnumRuleCall(); | ||
| 3242 | } | ||
| 3243 | ) | ||
| 3244 | ) | ||
| 3245 | ) | ||
| 3246 | | | ||
| 3247 | ( | ||
| 3248 | ( | ||
| 3249 | ( | ||
| 3250 | { | ||
| 3251 | if ($current==null) { | ||
| 3252 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 3253 | } | ||
| 3254 | } | ||
| 3255 | { | ||
| 3256 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | ||
| 3257 | } | ||
| 3258 | ruleQualifiedName | ||
| 3259 | { | ||
| 3260 | afterParserOrEnumRuleCall(); | ||
| 3261 | } | ||
| 3262 | ) | ||
| 3263 | ) | ||
| 3264 | otherlv_5=GreaterThanSignEqualsSign | ||
| 3265 | { | ||
| 3266 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 3267 | } | ||
| 3268 | ( | ||
| 3269 | ( | ||
| 3270 | lv_lowerBound_6_0=RULE_INT | ||
| 3271 | { | ||
| 3272 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | ||
| 3273 | } | ||
| 3274 | { | ||
| 3275 | if ($current==null) { | ||
| 3276 | $current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 3277 | } | ||
| 3278 | setWithLastConsumed( | ||
| 3279 | $current, | ||
| 3280 | "lowerBound", | ||
| 3281 | lv_lowerBound_6_0, | ||
| 3282 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 3283 | } | ||
| 3284 | ) | ||
| 3285 | ) | ||
| 3286 | ) | ||
| 3287 | ) | ||
| 3288 | ) | ||
| 3289 | ; | ||
| 3290 | |||
| 3291 | // Entry rule entryRuleObjectiveDefinition | ||
| 3292 | entryRuleObjectiveDefinition returns [EObject current=null]: | ||
| 3293 | { newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); } | ||
| 3294 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition | ||
| 3295 | { $current=$iv_ruleObjectiveDefinition.current; } | ||
| 3296 | EOF; | ||
| 3297 | |||
| 3298 | // Rule ObjectiveDefinition | ||
| 3299 | ruleObjectiveDefinition returns [EObject current=null] | ||
| 3300 | @init { | ||
| 3301 | enterRule(); | ||
| 3302 | } | ||
| 3303 | @after { | ||
| 3304 | leaveRule(); | ||
| 3305 | }: | ||
| 3306 | ( | ||
| 3307 | ( | ||
| 3308 | ( | ||
| 3309 | { | ||
| 3310 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); | ||
| 3311 | } | ||
| 3312 | lv_kind_0_0=ruleObjectiveKind | ||
| 3313 | { | ||
| 3314 | if ($current==null) { | ||
| 3315 | $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 3316 | } | ||
| 3317 | set( | ||
| 3318 | $current, | ||
| 3319 | "kind", | ||
| 3320 | lv_kind_0_0, | ||
| 3321 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
| 3322 | afterParserOrEnumRuleCall(); | ||
| 3323 | } | ||
| 3324 | ) | ||
| 3325 | ) | ||
| 3326 | ( | ||
| 3327 | ( | ||
| 3328 | { | ||
| 3329 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
| 3330 | } | ||
| 3331 | lv_objective_1_0=ruleExpression | ||
| 3332 | { | ||
| 3333 | if ($current==null) { | ||
| 3334 | $current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 3335 | } | ||
| 3336 | set( | ||
| 3337 | $current, | ||
| 3338 | "objective", | ||
| 3339 | lv_objective_1_0, | ||
| 3340 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 3341 | afterParserOrEnumRuleCall(); | ||
| 3342 | } | ||
| 3343 | ) | ||
| 3344 | ) | ||
| 3345 | ) | ||
| 3346 | ; | ||
| 3347 | |||
| 3348 | // Entry rule entryRuleUpperMultiplicty | ||
| 3349 | entryRuleUpperMultiplicty returns [String current=null]: | ||
| 3350 | { newCompositeNode(grammarAccess.getUpperMultiplictyRule()); } | ||
| 3351 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty | ||
| 3352 | { $current=$iv_ruleUpperMultiplicty.current.getText(); } | ||
| 3353 | EOF; | ||
| 3354 | |||
| 3355 | // Rule UpperMultiplicty | ||
| 3356 | ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 3357 | @init { | ||
| 3358 | enterRule(); | ||
| 3359 | } | ||
| 3360 | @after { | ||
| 3361 | leaveRule(); | ||
| 3362 | }: | ||
| 3363 | ( | ||
| 3364 | this_INT_0=RULE_INT | ||
| 3365 | { | ||
| 3366 | $current.merge(this_INT_0); | ||
| 3367 | } | ||
| 3368 | { | ||
| 3369 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | ||
| 3370 | } | ||
| 3371 | | | ||
| 3372 | kw=Asterisk | ||
| 3373 | { | ||
| 3374 | $current.merge(kw); | ||
| 3375 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
| 3376 | } | ||
| 3377 | ) | ||
| 3378 | ; | ||
| 3379 | |||
| 3380 | // Entry rule entryRuleReal | ||
| 3381 | entryRuleReal returns [String current=null]@init { | ||
| 3382 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 3383 | }: | ||
| 3384 | { newCompositeNode(grammarAccess.getRealRule()); } | ||
| 3385 | iv_ruleReal=ruleReal | ||
| 3386 | { $current=$iv_ruleReal.current.getText(); } | ||
| 3387 | EOF; | ||
| 3388 | finally { | ||
| 3389 | myHiddenTokenState.restore(); | ||
| 3390 | } | ||
| 3391 | |||
| 3392 | // Rule Real | ||
| 3393 | ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 3394 | @init { | ||
| 3395 | enterRule(); | ||
| 3396 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 3397 | } | ||
| 3398 | @after { | ||
| 3399 | leaveRule(); | ||
| 3400 | }: | ||
| 3401 | ( | ||
| 3402 | this_INT_0=RULE_INT | ||
| 3403 | { | ||
| 3404 | $current.merge(this_INT_0); | ||
| 3405 | } | ||
| 3406 | { | ||
| 3407 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | ||
| 3408 | } | ||
| 3409 | ( | ||
| 3410 | kw=FullStop | ||
| 3411 | { | ||
| 3412 | $current.merge(kw); | ||
| 3413 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | ||
| 3414 | } | ||
| 3415 | this_INT_2=RULE_INT | ||
| 3416 | { | ||
| 3417 | $current.merge(this_INT_2); | ||
| 3418 | } | ||
| 3419 | { | ||
| 3420 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | ||
| 3421 | } | ||
| 3422 | )? | ||
| 3423 | ) | ||
| 3424 | ; | ||
| 3425 | finally { | ||
| 3426 | myHiddenTokenState.restore(); | ||
| 3427 | } | ||
| 3428 | |||
| 3429 | // Entry rule entryRuleQualifiedName | ||
| 3430 | entryRuleQualifiedName returns [String current=null]@init { | ||
| 3431 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 3432 | }: | ||
| 3433 | { newCompositeNode(grammarAccess.getQualifiedNameRule()); } | ||
| 3434 | iv_ruleQualifiedName=ruleQualifiedName | ||
| 3435 | { $current=$iv_ruleQualifiedName.current.getText(); } | ||
| 3436 | EOF; | ||
| 3437 | finally { | ||
| 3438 | myHiddenTokenState.restore(); | ||
| 3439 | } | ||
| 3440 | |||
| 3441 | // Rule QualifiedName | ||
| 3442 | ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
| 3443 | @init { | ||
| 3444 | enterRule(); | ||
| 3445 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 3446 | } | ||
| 3447 | @after { | ||
| 3448 | leaveRule(); | ||
| 3449 | }: | ||
| 3450 | ( | ||
| 3451 | ( | ||
| 3452 | this_ID_0=RULE_ID | ||
| 3453 | { | ||
| 3454 | $current.merge(this_ID_0); | ||
| 3455 | } | ||
| 3456 | { | ||
| 3457 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | ||
| 3458 | } | ||
| 3459 | ( | ||
| 3460 | kw=FullStop | ||
| 3461 | { | ||
| 3462 | $current.merge(kw); | ||
| 3463 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | ||
| 3464 | } | ||
| 3465 | this_ID_2=RULE_ID | ||
| 3466 | { | ||
| 3467 | $current.merge(this_ID_2); | ||
| 3468 | } | ||
| 3469 | { | ||
| 3470 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | ||
| 3471 | } | ||
| 3472 | )* | ||
| 3473 | ) | ||
| 3474 | | | ||
| 3475 | this_QUOTED_ID_3=RULE_QUOTED_ID | ||
| 3476 | { | ||
| 3477 | $current.merge(this_QUOTED_ID_3); | ||
| 3478 | } | ||
| 3479 | { | ||
| 3480 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
| 3481 | } | ||
| 3482 | ) | ||
| 3483 | ; | ||
| 3484 | finally { | ||
| 3485 | myHiddenTokenState.restore(); | ||
| 3486 | } | ||
| 3487 | |||
| 3488 | // Rule MetricType | ||
| 3489 | ruleMetricType returns [Enumerator current=null] | ||
| 3490 | @init { | ||
| 3491 | enterRule(); | ||
| 3492 | } | ||
| 3493 | @after { | ||
| 3494 | leaveRule(); | ||
| 3495 | }: | ||
| 3496 | ( | ||
| 3497 | ( | ||
| 3498 | enumLiteral_0=Int | ||
| 3499 | { | ||
| 3500 | $current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3501 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | ||
| 3502 | } | ||
| 3503 | ) | ||
| 3504 | | | ||
| 3505 | ( | ||
| 3506 | enumLiteral_1=Real | ||
| 3507 | { | ||
| 3508 | $current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3509 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | ||
| 3510 | } | ||
| 3511 | ) | ||
| 3512 | ) | ||
| 3513 | ; | ||
| 3514 | |||
| 3515 | // Rule ComparisonOperator | ||
| 3516 | ruleComparisonOperator returns [Enumerator current=null] | ||
| 3517 | @init { | ||
| 3518 | enterRule(); | ||
| 3519 | } | ||
| 3520 | @after { | ||
| 3521 | leaveRule(); | ||
| 3522 | }: | ||
| 3523 | ( | ||
| 3524 | ( | ||
| 3525 | enumLiteral_0=EqualsSignEqualsSign | ||
| 3526 | { | ||
| 3527 | $current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3528 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | ||
| 3529 | } | ||
| 3530 | ) | ||
| 3531 | | | ||
| 3532 | ( | ||
| 3533 | enumLiteral_1=ExclamationMarkEqualsSign | ||
| 3534 | { | ||
| 3535 | $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3536 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | ||
| 3537 | } | ||
| 3538 | ) | ||
| 3539 | | | ||
| 3540 | ( | ||
| 3541 | enumLiteral_2=LessThanSign | ||
| 3542 | { | ||
| 3543 | $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3544 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
| 3545 | } | ||
| 3546 | ) | ||
| 3547 | | | ||
| 3548 | ( | ||
| 3549 | enumLiteral_3=LessThanSignEqualsSign | ||
| 3550 | { | ||
| 3551 | $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3552 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | ||
| 3553 | } | ||
| 3554 | ) | ||
| 3555 | | | ||
| 3556 | ( | ||
| 3557 | enumLiteral_4=GreaterThanSign | ||
| 3558 | { | ||
| 3559 | $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 3560 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
| 3561 | } | ||
| 3562 | ) | ||
| 3563 | | | ||
| 3564 | ( | ||
| 3565 | enumLiteral_5=GreaterThanSignEqualsSign | ||
| 3566 | { | ||
| 3567 | $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 3568 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | ||
| 3569 | } | ||
| 3570 | ) | ||
| 3571 | | | ||
| 3572 | ( | ||
| 3573 | enumLiteral_6=In | ||
| 3574 | { | ||
| 3575 | $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
| 3576 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
| 3577 | } | ||
| 3578 | ) | ||
| 3579 | ) | ||
| 3580 | ; | ||
| 3581 | |||
| 3582 | // Rule AdditiveBinaryOperator | ||
| 3583 | ruleAdditiveBinaryOperator returns [Enumerator current=null] | ||
| 3584 | @init { | ||
| 3585 | enterRule(); | ||
| 3586 | } | ||
| 3587 | @after { | ||
| 3588 | leaveRule(); | ||
| 3589 | }: | ||
| 3590 | ( | ||
| 3591 | ( | ||
| 3592 | enumLiteral_0=PlusSign | ||
| 3593 | { | ||
| 3594 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3595 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | ||
| 3596 | } | ||
| 3597 | ) | ||
| 3598 | | | ||
| 3599 | ( | ||
| 3600 | enumLiteral_1=HyphenMinus | ||
| 3601 | { | ||
| 3602 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3603 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | ||
| 3604 | } | ||
| 3605 | ) | ||
| 3606 | ) | ||
| 3607 | ; | ||
| 3608 | |||
| 3609 | // Rule MultiplicativeBinaryOperator | ||
| 3610 | ruleMultiplicativeBinaryOperator returns [Enumerator current=null] | ||
| 3611 | @init { | ||
| 3612 | enterRule(); | ||
| 3613 | } | ||
| 3614 | @after { | ||
| 3615 | leaveRule(); | ||
| 3616 | }: | ||
| 3617 | ( | ||
| 3618 | ( | ||
| 3619 | enumLiteral_0=Asterisk | ||
| 3620 | { | ||
| 3621 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3622 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | ||
| 3623 | } | ||
| 3624 | ) | ||
| 3625 | | | ||
| 3626 | ( | ||
| 3627 | enumLiteral_1=Solidus | ||
| 3628 | { | ||
| 3629 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3630 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | ||
| 3631 | } | ||
| 3632 | ) | ||
| 3633 | ) | ||
| 3634 | ; | ||
| 3635 | |||
| 3636 | // Rule ExponentialOp | ||
| 3637 | ruleExponentialOp returns [Enumerator current=null] | ||
| 3638 | @init { | ||
| 3639 | enterRule(); | ||
| 3640 | } | ||
| 3641 | @after { | ||
| 3642 | leaveRule(); | ||
| 3643 | }: | ||
| 3644 | ( | ||
| 3645 | enumLiteral_0=CircumflexAccent | ||
| 3646 | { | ||
| 3647 | $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | ||
| 3648 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
| 3649 | } | ||
| 3650 | ) | ||
| 3651 | ; | ||
| 3652 | |||
| 3653 | // Rule UnaryOp | ||
| 3654 | ruleUnaryOp returns [Enumerator current=null] | ||
| 3655 | @init { | ||
| 3656 | enterRule(); | ||
| 3657 | } | ||
| 3658 | @after { | ||
| 3659 | leaveRule(); | ||
| 3660 | }: | ||
| 3661 | ( | ||
| 3662 | ( | ||
| 3663 | enumLiteral_0=ExclamationMark | ||
| 3664 | { | ||
| 3665 | $current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3666 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | ||
| 3667 | } | ||
| 3668 | ) | ||
| 3669 | | | ||
| 3670 | ( | ||
| 3671 | enumLiteral_1=PlusSign | ||
| 3672 | { | ||
| 3673 | $current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3674 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | ||
| 3675 | } | ||
| 3676 | ) | ||
| 3677 | | | ||
| 3678 | ( | ||
| 3679 | enumLiteral_2=HyphenMinus | ||
| 3680 | { | ||
| 3681 | $current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3682 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | ||
| 3683 | } | ||
| 3684 | ) | ||
| 3685 | | | ||
| 3686 | ( | ||
| 3687 | enumLiteral_3=May | ||
| 3688 | { | ||
| 3689 | $current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3690 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | ||
| 3691 | } | ||
| 3692 | ) | ||
| 3693 | | | ||
| 3694 | ( | ||
| 3695 | enumLiteral_4=Must | ||
| 3696 | { | ||
| 3697 | $current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 3698 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | ||
| 3699 | } | ||
| 3700 | ) | ||
| 3701 | | | ||
| 3702 | ( | ||
| 3703 | enumLiteral_5=Current | ||
| 3704 | { | ||
| 3705 | $current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 3706 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | ||
| 3707 | } | ||
| 3708 | ) | ||
| 3709 | ) | ||
| 3710 | ; | ||
| 3711 | |||
| 3712 | // Rule AggregationOp | ||
| 3713 | ruleAggregationOp returns [Enumerator current=null] | ||
| 3714 | @init { | ||
| 3715 | enterRule(); | ||
| 3716 | } | ||
| 3717 | @after { | ||
| 3718 | leaveRule(); | ||
| 3719 | }: | ||
| 3720 | ( | ||
| 3721 | ( | ||
| 3722 | enumLiteral_0=Only | ||
| 3723 | { | ||
| 3724 | $current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3725 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | ||
| 3726 | } | ||
| 3727 | ) | ||
| 3728 | | | ||
| 3729 | ( | ||
| 3730 | enumLiteral_1=Sum | ||
| 3731 | { | ||
| 3732 | $current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3733 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | ||
| 3734 | } | ||
| 3735 | ) | ||
| 3736 | | | ||
| 3737 | ( | ||
| 3738 | enumLiteral_2=Prod | ||
| 3739 | { | ||
| 3740 | $current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3741 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | ||
| 3742 | } | ||
| 3743 | ) | ||
| 3744 | | | ||
| 3745 | ( | ||
| 3746 | enumLiteral_3=Avg | ||
| 3747 | { | ||
| 3748 | $current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3749 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | ||
| 3750 | } | ||
| 3751 | ) | ||
| 3752 | | | ||
| 3753 | ( | ||
| 3754 | enumLiteral_4=Min | ||
| 3755 | { | ||
| 3756 | $current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 3757 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | ||
| 3758 | } | ||
| 3759 | ) | ||
| 3760 | | | ||
| 3761 | ( | ||
| 3762 | enumLiteral_5=Max | ||
| 3763 | { | ||
| 3764 | $current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 3765 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | ||
| 3766 | } | ||
| 3767 | ) | ||
| 3768 | ) | ||
| 3769 | ; | ||
| 3770 | |||
| 3771 | // Rule LogicValue | ||
| 3772 | ruleLogicValue returns [Enumerator current=null] | ||
| 3773 | @init { | ||
| 3774 | enterRule(); | ||
| 3775 | } | ||
| 3776 | @after { | ||
| 3777 | leaveRule(); | ||
| 3778 | }: | ||
| 3779 | ( | ||
| 3780 | ( | ||
| 3781 | enumLiteral_0=True | ||
| 3782 | { | ||
| 3783 | $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3784 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
| 3785 | } | ||
| 3786 | ) | ||
| 3787 | | | ||
| 3788 | ( | ||
| 3789 | enumLiteral_1=False | ||
| 3790 | { | ||
| 3791 | $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3792 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
| 3793 | } | ||
| 3794 | ) | ||
| 3795 | | | ||
| 3796 | ( | ||
| 3797 | enumLiteral_2=Unknown | ||
| 3798 | { | ||
| 3799 | $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 3800 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
| 3801 | } | ||
| 3802 | ) | ||
| 3803 | | | ||
| 3804 | ( | ||
| 3805 | enumLiteral_3=Error | ||
| 3806 | { | ||
| 3807 | $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 3808 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
| 3809 | } | ||
| 3810 | ) | ||
| 3811 | ) | ||
| 3812 | ; | ||
| 3813 | |||
| 3814 | // Rule ObjectiveKind | ||
| 3815 | ruleObjectiveKind returns [Enumerator current=null] | ||
| 3816 | @init { | ||
| 3817 | enterRule(); | ||
| 3818 | } | ||
| 3819 | @after { | ||
| 3820 | leaveRule(); | ||
| 3821 | }: | ||
| 3822 | ( | ||
| 3823 | ( | ||
| 3824 | enumLiteral_0=Minimize | ||
| 3825 | { | ||
| 3826 | $current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 3827 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | ||
| 3828 | } | ||
| 3829 | ) | ||
| 3830 | | | ||
| 3831 | ( | ||
| 3832 | enumLiteral_1=Maximize | ||
| 3833 | { | ||
| 3834 | $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 3835 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | ||
| 3836 | } | ||
| 3837 | ) | ||
| 3838 | ) | ||
| 3839 | ; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java index 1d449e49..7dbfa002 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java | |||
| @@ -5,6 +5,7 @@ import org.eclipse.xtext.parser.*; | |||
| 5 | import org.eclipse.xtext.parser.impl.*; | 5 | import org.eclipse.xtext.parser.impl.*; |
| 6 | import org.eclipse.emf.ecore.util.EcoreUtil; | 6 | import org.eclipse.emf.ecore.util.EcoreUtil; |
| 7 | import org.eclipse.emf.ecore.EObject; | 7 | import org.eclipse.emf.ecore.EObject; |
| 8 | import org.eclipse.emf.common.util.Enumerator; | ||
| 8 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | 9 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; |
| 9 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| 10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | 11 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| @@ -21,47 +22,92 @@ import java.util.ArrayList; | |||
| 21 | @SuppressWarnings("all") | 22 | @SuppressWarnings("all") |
| 22 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | 23 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { |
| 23 | public static final String[] tokenNames = new String[] { | 24 | public static final String[] tokenNames = new String[] { |
| 24 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'.'", "'true'", "'false'", "'unknown'", "'error'", "'('", "','", "')'", "':'", "'exists'", "'equals'", "'bool'", "'int'", "'real'", "'string'", "'\\''", "':-'", "'|'", "'+'", "'*'", "'default'", "'abstract'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'containment'", "'relation'", "'..'" | 25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "GREATER_EQ", "Functional", "Abstract", "Contains", "Maximize", "Minimize", "Opposite", "GREATER", "LESS_EQ", "Current", "Default", "Extends", "Unknown", "NOT_EQ", "Extern", "Class", "Count", "Empty", "Error", "False", "Scope", "LESS", "Else", "Must", "Only", "Prod", "Real", "Then", "True", "ADD", "DIV", "MUL", "POW", "SUB", "Avg", "Inf", "Int", "Max", "May", "Min", "Sum", "ExclamationMarkEqualsSign", "HyphenMinusGreaterThanSign", "FullStopFullStop", "ColonHyphenMinus", "LessThanSignEqualsSign", "EqualsSignEqualsSign", "GreaterThanSignEqualsSign", "EQ", "IN", "If", "In", "ExclamationMark", "LeftParenthesis", "RightParenthesis", "Asterisk", "PlusSign", "Comma", "HyphenMinus", "FullStop", "Solidus", "Colon", "Semicolon", "LessThanSign", "EqualsSign", "GreaterThanSign", "LeftSquareBracket", "RightSquareBracket", "CircumflexAccent", "LeftCurlyBracket", "VerticalLine", "RightCurlyBracket", "RULE_STRING", "RULE_QUOTED_ID", "RULE_SL_COMMENT", "RULE_TRANSITIVE_CLOSURE", "RULE_REFLEXIVE_TRANSITIVE_CLOSURE", "RULE_FULL_STOP", "RULE_ID", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" |
| 25 | }; | 26 | }; |
| 26 | public static final int RULE_STRING=6; | 27 | public static final int ADD=33; |
| 27 | public static final int RULE_SL_COMMENT=8; | 28 | public static final int True=32; |
| 28 | public static final int T__19=19; | 29 | public static final int GREATER_EQ=4; |
| 29 | public static final int T__15=15; | 30 | public static final int Count=20; |
| 30 | public static final int T__37=37; | 31 | public static final int False=23; |
| 31 | public static final int T__16=16; | 32 | public static final int Must=27; |
| 32 | public static final int T__38=38; | 33 | public static final int LessThanSign=67; |
| 33 | public static final int T__17=17; | 34 | public static final int LeftParenthesis=57; |
| 34 | public static final int T__39=39; | 35 | public static final int Unknown=16; |
| 35 | public static final int T__18=18; | 36 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80; |
| 36 | public static final int T__11=11; | 37 | public static final int FullStopFullStop=47; |
| 37 | public static final int T__33=33; | 38 | public static final int Real=30; |
| 38 | public static final int T__12=12; | 39 | public static final int Then=31; |
| 39 | public static final int T__34=34; | 40 | public static final int Extends=15; |
| 40 | public static final int T__13=13; | 41 | public static final int RightSquareBracket=71; |
| 41 | public static final int T__35=35; | 42 | public static final int ExclamationMark=56; |
| 42 | public static final int T__14=14; | 43 | public static final int Opposite=10; |
| 43 | public static final int T__36=36; | 44 | public static final int SUB=37; |
| 45 | public static final int GreaterThanSign=69; | ||
| 46 | public static final int NOT_EQ=17; | ||
| 47 | public static final int RULE_ID=82; | ||
| 48 | public static final int MUL=35; | ||
| 49 | public static final int IN=53; | ||
| 50 | public static final int RULE_QUOTED_ID=77; | ||
| 51 | public static final int RightParenthesis=58; | ||
| 52 | public static final int Sum=44; | ||
| 53 | public static final int EQ=52; | ||
| 54 | public static final int GreaterThanSignEqualsSign=51; | ||
| 55 | public static final int Functional=5; | ||
| 56 | public static final int EqualsSignEqualsSign=50; | ||
| 57 | public static final int Avg=38; | ||
| 58 | public static final int Min=43; | ||
| 59 | public static final int VerticalLine=74; | ||
| 60 | public static final int PlusSign=60; | ||
| 61 | public static final int RULE_INT=83; | ||
| 62 | public static final int Contains=7; | ||
| 63 | public static final int RULE_ML_COMMENT=84; | ||
| 64 | public static final int POW=36; | ||
| 65 | public static final int RULE_TRANSITIVE_CLOSURE=79; | ||
| 66 | public static final int Class=19; | ||
| 67 | public static final int LESS=25; | ||
| 68 | public static final int LeftSquareBracket=70; | ||
| 69 | public static final int RULE_FULL_STOP=81; | ||
| 70 | public static final int Current=13; | ||
| 71 | public static final int If=54; | ||
| 72 | public static final int Inf=39; | ||
| 73 | public static final int LESS_EQ=12; | ||
| 74 | public static final int May=42; | ||
| 75 | public static final int Max=41; | ||
| 76 | public static final int In=55; | ||
| 77 | public static final int RULE_STRING=76; | ||
| 78 | public static final int Int=40; | ||
| 79 | public static final int Extern=18; | ||
| 80 | public static final int RULE_SL_COMMENT=78; | ||
| 81 | public static final int Prod=29; | ||
| 82 | public static final int Comma=61; | ||
| 83 | public static final int EqualsSign=68; | ||
| 84 | public static final int Empty=21; | ||
| 85 | public static final int HyphenMinus=62; | ||
| 86 | public static final int Maximize=8; | ||
| 87 | public static final int LessThanSignEqualsSign=49; | ||
| 88 | public static final int Solidus=64; | ||
| 89 | public static final int Colon=65; | ||
| 90 | public static final int RightCurlyBracket=75; | ||
| 44 | public static final int EOF=-1; | 91 | public static final int EOF=-1; |
| 45 | public static final int T__30=30; | 92 | public static final int Asterisk=59; |
| 46 | public static final int T__31=31; | 93 | public static final int FullStop=63; |
| 47 | public static final int T__32=32; | 94 | public static final int RULE_WS=85; |
| 48 | public static final int RULE_ID=5; | 95 | public static final int Abstract=6; |
| 49 | public static final int RULE_WS=9; | 96 | public static final int Minimize=9; |
| 50 | public static final int RULE_ANY_OTHER=10; | 97 | public static final int GREATER=11; |
| 51 | public static final int T__26=26; | 98 | public static final int LeftCurlyBracket=73; |
| 52 | public static final int T__27=27; | 99 | public static final int Error=22; |
| 53 | public static final int T__28=28; | 100 | public static final int Only=28; |
| 54 | public static final int RULE_INT=4; | 101 | public static final int RULE_ANY_OTHER=86; |
| 55 | public static final int T__29=29; | 102 | public static final int Default=14; |
| 56 | public static final int T__22=22; | 103 | public static final int ColonHyphenMinus=48; |
| 57 | public static final int RULE_ML_COMMENT=7; | 104 | public static final int CircumflexAccent=72; |
| 58 | public static final int T__23=23; | 105 | public static final int DIV=34; |
| 59 | public static final int T__24=24; | 106 | public static final int Semicolon=66; |
| 60 | public static final int T__25=25; | 107 | public static final int Scope=24; |
| 61 | public static final int T__40=40; | 108 | public static final int Else=26; |
| 62 | public static final int T__41=41; | 109 | public static final int ExclamationMarkEqualsSign=45; |
| 63 | public static final int T__20=20; | 110 | public static final int HyphenMinusGreaterThanSign=46; |
| 64 | public static final int T__21=21; | ||
| 65 | 111 | ||
| 66 | // delegates | 112 | // delegates |
| 67 | // delegators | 113 | // delegators |
| @@ -77,7 +123,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 77 | 123 | ||
| 78 | 124 | ||
| 79 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } | 125 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } |
| 80 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | 126 | public String getGrammarFileName() { return "InternalSolverLanguageParser.g"; } |
| 81 | 127 | ||
| 82 | 128 | ||
| 83 | 129 | ||
| @@ -103,7 +149,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 103 | 149 | ||
| 104 | 150 | ||
| 105 | // $ANTLR start "entryRuleProblem" | 151 | // $ANTLR start "entryRuleProblem" |
| 106 | // InternalSolverLanguage.g:64:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; | 152 | // InternalSolverLanguageParser.g:58:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; |
| 107 | public final EObject entryRuleProblem() throws RecognitionException { | 153 | public final EObject entryRuleProblem() throws RecognitionException { |
| 108 | EObject current = null; | 154 | EObject current = null; |
| 109 | 155 | ||
| @@ -111,8 +157,8 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 111 | 157 | ||
| 112 | 158 | ||
| 113 | try { | 159 | try { |
| 114 | // InternalSolverLanguage.g:64:48: (iv_ruleProblem= ruleProblem EOF ) | 160 | // InternalSolverLanguageParser.g:58:48: (iv_ruleProblem= ruleProblem EOF ) |
| 115 | // InternalSolverLanguage.g:65:2: iv_ruleProblem= ruleProblem EOF | 161 | // InternalSolverLanguageParser.g:59:2: iv_ruleProblem= ruleProblem EOF |
| 116 | { | 162 | { |
| 117 | newCompositeNode(grammarAccess.getProblemRule()); | 163 | newCompositeNode(grammarAccess.getProblemRule()); |
| 118 | pushFollow(FOLLOW_1); | 164 | pushFollow(FOLLOW_1); |
| @@ -139,7 +185,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 139 | 185 | ||
| 140 | 186 | ||
| 141 | // $ANTLR start "ruleProblem" | 187 | // $ANTLR start "ruleProblem" |
| 142 | // InternalSolverLanguage.g:71:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; | 188 | // InternalSolverLanguageParser.g:65:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; |
| 143 | public final EObject ruleProblem() throws RecognitionException { | 189 | public final EObject ruleProblem() throws RecognitionException { |
| 144 | EObject current = null; | 190 | EObject current = null; |
| 145 | 191 | ||
| @@ -150,26 +196,26 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 150 | enterRule(); | 196 | enterRule(); |
| 151 | 197 | ||
| 152 | try { | 198 | try { |
| 153 | // InternalSolverLanguage.g:77:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) | 199 | // InternalSolverLanguageParser.g:71:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) |
| 154 | // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* | 200 | // InternalSolverLanguageParser.g:72:2: ( (lv_statements_0_0= ruleStatement ) )* |
| 155 | { | 201 | { |
| 156 | // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* | 202 | // InternalSolverLanguageParser.g:72:2: ( (lv_statements_0_0= ruleStatement ) )* |
| 157 | loop1: | 203 | loop1: |
| 158 | do { | 204 | do { |
| 159 | int alt1=2; | 205 | int alt1=2; |
| 160 | int LA1_0 = input.LA(1); | 206 | int LA1_0 = input.LA(1); |
| 161 | 207 | ||
| 162 | if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=21 && LA1_0<=26)||(LA1_0>=32 && LA1_0<=34)||(LA1_0>=38 && LA1_0<=40)) ) { | 208 | if ( ((LA1_0>=Functional && LA1_0<=Abstract)||(LA1_0>=Maximize && LA1_0<=Minimize)||(LA1_0>=Current && LA1_0<=Default)||LA1_0==Unknown||(LA1_0>=Extern && LA1_0<=False)||LA1_0==Scope||(LA1_0>=Must && LA1_0<=Real)||LA1_0==True||(LA1_0>=Avg && LA1_0<=Sum)||LA1_0==If||(LA1_0>=ExclamationMark && LA1_0<=LeftParenthesis)||LA1_0==PlusSign||LA1_0==HyphenMinus||LA1_0==LeftSquareBracket||(LA1_0>=RULE_STRING && LA1_0<=RULE_QUOTED_ID)||(LA1_0>=RULE_ID && LA1_0<=RULE_INT)) ) { |
| 163 | alt1=1; | 209 | alt1=1; |
| 164 | } | 210 | } |
| 165 | 211 | ||
| 166 | 212 | ||
| 167 | switch (alt1) { | 213 | switch (alt1) { |
| 168 | case 1 : | 214 | case 1 : |
| 169 | // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) | 215 | // InternalSolverLanguageParser.g:73:3: (lv_statements_0_0= ruleStatement ) |
| 170 | { | 216 | { |
| 171 | // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) | 217 | // InternalSolverLanguageParser.g:73:3: (lv_statements_0_0= ruleStatement ) |
| 172 | // InternalSolverLanguage.g:80:4: lv_statements_0_0= ruleStatement | 218 | // InternalSolverLanguageParser.g:74:4: lv_statements_0_0= ruleStatement |
| 173 | { | 219 | { |
| 174 | 220 | ||
| 175 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | 221 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); |
| @@ -222,7 +268,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 222 | 268 | ||
| 223 | 269 | ||
| 224 | // $ANTLR start "entryRuleStatement" | 270 | // $ANTLR start "entryRuleStatement" |
| 225 | // InternalSolverLanguage.g:100:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; | 271 | // InternalSolverLanguageParser.g:94:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; |
| 226 | public final EObject entryRuleStatement() throws RecognitionException { | 272 | public final EObject entryRuleStatement() throws RecognitionException { |
| 227 | EObject current = null; | 273 | EObject current = null; |
| 228 | 274 | ||
| @@ -230,8 +276,8 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 230 | 276 | ||
| 231 | 277 | ||
| 232 | try { | 278 | try { |
| 233 | // InternalSolverLanguage.g:100:50: (iv_ruleStatement= ruleStatement EOF ) | 279 | // InternalSolverLanguageParser.g:94:50: (iv_ruleStatement= ruleStatement EOF ) |
| 234 | // InternalSolverLanguage.g:101:2: iv_ruleStatement= ruleStatement EOF | 280 | // InternalSolverLanguageParser.g:95:2: iv_ruleStatement= ruleStatement EOF |
| 235 | { | 281 | { |
| 236 | newCompositeNode(grammarAccess.getStatementRule()); | 282 | newCompositeNode(grammarAccess.getStatementRule()); |
| 237 | pushFollow(FOLLOW_1); | 283 | pushFollow(FOLLOW_1); |
| @@ -258,179 +304,232 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 258 | 304 | ||
| 259 | 305 | ||
| 260 | // $ANTLR start "ruleStatement" | 306 | // $ANTLR start "ruleStatement" |
| 261 | // InternalSolverLanguage.g:107:1: ruleStatement returns [EObject current=null] : (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ; | 307 | // InternalSolverLanguageParser.g:101:1: ruleStatement returns [EObject current=null] : ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) ; |
| 262 | public final EObject ruleStatement() throws RecognitionException { | 308 | public final EObject ruleStatement() throws RecognitionException { |
| 263 | EObject current = null; | 309 | EObject current = null; |
| 264 | 310 | ||
| 265 | EObject this_Interpretation_0 = null; | 311 | Token this_FULL_STOP_10=null; |
| 312 | EObject this_AssertionOrDefinition_0 = null; | ||
| 266 | 313 | ||
| 267 | EObject this_Predicate_1 = null; | 314 | EObject this_PredicateDefinition_1 = null; |
| 315 | |||
| 316 | EObject this_UnnamedErrorPrediateDefinition_2 = null; | ||
| 317 | |||
| 318 | EObject this_DefaultDefinition_3 = null; | ||
| 319 | |||
| 320 | EObject this_ExternPredicateDefinition_4 = null; | ||
| 321 | |||
| 322 | EObject this_MetricDefinition_5 = null; | ||
| 323 | |||
| 324 | EObject this_ExternMetricDefinition_6 = null; | ||
| 325 | |||
| 326 | EObject this_ClassDefinition_7 = null; | ||
| 327 | |||
| 328 | EObject this_ScopeDefinition_8 = null; | ||
| 329 | |||
| 330 | EObject this_ObjectiveDefinition_9 = null; | ||
| 268 | 331 | ||
| 269 | 332 | ||
| 270 | 333 | ||
| 271 | enterRule(); | 334 | enterRule(); |
| 272 | 335 | ||
| 273 | try { | 336 | try { |
| 274 | // InternalSolverLanguage.g:113:2: ( (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ) | 337 | // InternalSolverLanguageParser.g:107:2: ( ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) ) |
| 275 | // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) | 338 | // InternalSolverLanguageParser.g:108:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) |
| 339 | { | ||
| 340 | // InternalSolverLanguageParser.g:108:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) | ||
| 341 | // InternalSolverLanguageParser.g:109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP | ||
| 276 | { | 342 | { |
| 277 | // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) | 343 | // InternalSolverLanguageParser.g:109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) |
| 278 | int alt2=2; | 344 | int alt2=10; |
| 279 | alt2 = dfa2.predict(input); | 345 | alt2 = dfa2.predict(input); |
| 280 | switch (alt2) { | 346 | switch (alt2) { |
| 281 | case 1 : | 347 | case 1 : |
| 282 | // InternalSolverLanguage.g:115:3: this_Interpretation_0= ruleInterpretation | 348 | // InternalSolverLanguageParser.g:110:4: this_AssertionOrDefinition_0= ruleAssertionOrDefinition |
| 283 | { | 349 | { |
| 284 | 350 | ||
| 285 | newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); | 351 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); |
| 286 | 352 | ||
| 287 | pushFollow(FOLLOW_2); | 353 | pushFollow(FOLLOW_4); |
| 288 | this_Interpretation_0=ruleInterpretation(); | 354 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition(); |
| 289 | 355 | ||
| 290 | state._fsp--; | 356 | state._fsp--; |
| 291 | 357 | ||
| 292 | 358 | ||
| 293 | current = this_Interpretation_0; | 359 | current = this_AssertionOrDefinition_0; |
| 294 | afterParserOrEnumRuleCall(); | 360 | afterParserOrEnumRuleCall(); |
| 295 | 361 | ||
| 296 | 362 | ||
| 297 | } | 363 | } |
| 298 | break; | 364 | break; |
| 299 | case 2 : | 365 | case 2 : |
| 300 | // InternalSolverLanguage.g:124:3: this_Predicate_1= rulePredicate | 366 | // InternalSolverLanguageParser.g:119:4: this_PredicateDefinition_1= rulePredicateDefinition |
| 301 | { | 367 | { |
| 302 | 368 | ||
| 303 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); | 369 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); |
| 304 | 370 | ||
| 305 | pushFollow(FOLLOW_2); | 371 | pushFollow(FOLLOW_4); |
| 306 | this_Predicate_1=rulePredicate(); | 372 | this_PredicateDefinition_1=rulePredicateDefinition(); |
| 307 | 373 | ||
| 308 | state._fsp--; | 374 | state._fsp--; |
| 309 | 375 | ||
| 310 | 376 | ||
| 311 | current = this_Predicate_1; | 377 | current = this_PredicateDefinition_1; |
| 312 | afterParserOrEnumRuleCall(); | 378 | afterParserOrEnumRuleCall(); |
| 313 | 379 | ||
| 314 | 380 | ||
| 315 | } | 381 | } |
| 316 | break; | 382 | break; |
| 383 | case 3 : | ||
| 384 | // InternalSolverLanguageParser.g:128:4: this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | ||
| 385 | { | ||
| 317 | 386 | ||
| 318 | } | 387 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); |
| 388 | |||
| 389 | pushFollow(FOLLOW_4); | ||
| 390 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition(); | ||
| 319 | 391 | ||
| 392 | state._fsp--; | ||
| 320 | 393 | ||
| 321 | } | ||
| 322 | 394 | ||
| 395 | current = this_UnnamedErrorPrediateDefinition_2; | ||
| 396 | afterParserOrEnumRuleCall(); | ||
| 397 | |||
| 323 | 398 | ||
| 324 | leaveRule(); | 399 | } |
| 400 | break; | ||
| 401 | case 4 : | ||
| 402 | // InternalSolverLanguageParser.g:137:4: this_DefaultDefinition_3= ruleDefaultDefinition | ||
| 403 | { | ||
| 325 | 404 | ||
| 326 | } | 405 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); |
| 406 | |||
| 407 | pushFollow(FOLLOW_4); | ||
| 408 | this_DefaultDefinition_3=ruleDefaultDefinition(); | ||
| 327 | 409 | ||
| 328 | catch (RecognitionException re) { | 410 | state._fsp--; |
| 329 | recover(input,re); | ||
| 330 | appendSkippedTokens(); | ||
| 331 | } | ||
| 332 | finally { | ||
| 333 | } | ||
| 334 | return current; | ||
| 335 | } | ||
| 336 | // $ANTLR end "ruleStatement" | ||
| 337 | 411 | ||
| 338 | 412 | ||
| 339 | // $ANTLR start "entryRuleREALLiteral" | 413 | current = this_DefaultDefinition_3; |
| 340 | // InternalSolverLanguage.g:136:1: entryRuleREALLiteral returns [String current=null] : iv_ruleREALLiteral= ruleREALLiteral EOF ; | 414 | afterParserOrEnumRuleCall(); |
| 341 | public final String entryRuleREALLiteral() throws RecognitionException { | 415 | |
| 342 | String current = null; | ||
| 343 | 416 | ||
| 344 | AntlrDatatypeRuleToken iv_ruleREALLiteral = null; | 417 | } |
| 418 | break; | ||
| 419 | case 5 : | ||
| 420 | // InternalSolverLanguageParser.g:146:4: this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | ||
| 421 | { | ||
| 345 | 422 | ||
| 423 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | ||
| 424 | |||
| 425 | pushFollow(FOLLOW_4); | ||
| 426 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition(); | ||
| 346 | 427 | ||
| 347 | try { | 428 | state._fsp--; |
| 348 | // InternalSolverLanguage.g:136:51: (iv_ruleREALLiteral= ruleREALLiteral EOF ) | ||
| 349 | // InternalSolverLanguage.g:137:2: iv_ruleREALLiteral= ruleREALLiteral EOF | ||
| 350 | { | ||
| 351 | newCompositeNode(grammarAccess.getREALLiteralRule()); | ||
| 352 | pushFollow(FOLLOW_1); | ||
| 353 | iv_ruleREALLiteral=ruleREALLiteral(); | ||
| 354 | 429 | ||
| 355 | state._fsp--; | ||
| 356 | 430 | ||
| 357 | current =iv_ruleREALLiteral.getText(); | 431 | current = this_ExternPredicateDefinition_4; |
| 358 | match(input,EOF,FOLLOW_2); | 432 | afterParserOrEnumRuleCall(); |
| 433 | |||
| 359 | 434 | ||
| 360 | } | 435 | } |
| 436 | break; | ||
| 437 | case 6 : | ||
| 438 | // InternalSolverLanguageParser.g:155:4: this_MetricDefinition_5= ruleMetricDefinition | ||
| 439 | { | ||
| 361 | 440 | ||
| 362 | } | 441 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); |
| 442 | |||
| 443 | pushFollow(FOLLOW_4); | ||
| 444 | this_MetricDefinition_5=ruleMetricDefinition(); | ||
| 363 | 445 | ||
| 364 | catch (RecognitionException re) { | 446 | state._fsp--; |
| 365 | recover(input,re); | ||
| 366 | appendSkippedTokens(); | ||
| 367 | } | ||
| 368 | finally { | ||
| 369 | } | ||
| 370 | return current; | ||
| 371 | } | ||
| 372 | // $ANTLR end "entryRuleREALLiteral" | ||
| 373 | 447 | ||
| 374 | 448 | ||
| 375 | // $ANTLR start "ruleREALLiteral" | 449 | current = this_MetricDefinition_5; |
| 376 | // InternalSolverLanguage.g:143:1: ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ; | 450 | afterParserOrEnumRuleCall(); |
| 377 | public final AntlrDatatypeRuleToken ruleREALLiteral() throws RecognitionException { | 451 | |
| 378 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
| 379 | 452 | ||
| 380 | Token kw=null; | 453 | } |
| 381 | Token this_INT_1=null; | 454 | break; |
| 382 | Token this_INT_3=null; | 455 | case 7 : |
| 456 | // InternalSolverLanguageParser.g:164:4: this_ExternMetricDefinition_6= ruleExternMetricDefinition | ||
| 457 | { | ||
| 383 | 458 | ||
| 459 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | ||
| 460 | |||
| 461 | pushFollow(FOLLOW_4); | ||
| 462 | this_ExternMetricDefinition_6=ruleExternMetricDefinition(); | ||
| 384 | 463 | ||
| 385 | enterRule(); | 464 | state._fsp--; |
| 386 | 465 | ||
| 387 | try { | ||
| 388 | // InternalSolverLanguage.g:149:2: ( ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ) | ||
| 389 | // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) | ||
| 390 | { | ||
| 391 | // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) | ||
| 392 | // InternalSolverLanguage.g:151:3: (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT | ||
| 393 | { | ||
| 394 | // InternalSolverLanguage.g:151:3: (kw= '-' )? | ||
| 395 | int alt3=2; | ||
| 396 | int LA3_0 = input.LA(1); | ||
| 397 | 466 | ||
| 398 | if ( (LA3_0==11) ) { | 467 | current = this_ExternMetricDefinition_6; |
| 399 | alt3=1; | 468 | afterParserOrEnumRuleCall(); |
| 400 | } | 469 | |
| 401 | switch (alt3) { | 470 | |
| 402 | case 1 : | 471 | } |
| 403 | // InternalSolverLanguage.g:152:4: kw= '-' | 472 | break; |
| 473 | case 8 : | ||
| 474 | // InternalSolverLanguageParser.g:173:4: this_ClassDefinition_7= ruleClassDefinition | ||
| 404 | { | 475 | { |
| 405 | kw=(Token)match(input,11,FOLLOW_4); | ||
| 406 | 476 | ||
| 407 | current.merge(kw); | 477 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); |
| 408 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); | 478 | |
| 479 | pushFollow(FOLLOW_4); | ||
| 480 | this_ClassDefinition_7=ruleClassDefinition(); | ||
| 481 | |||
| 482 | state._fsp--; | ||
| 483 | |||
| 484 | |||
| 485 | current = this_ClassDefinition_7; | ||
| 486 | afterParserOrEnumRuleCall(); | ||
| 409 | 487 | ||
| 410 | 488 | ||
| 411 | } | 489 | } |
| 412 | break; | 490 | break; |
| 491 | case 9 : | ||
| 492 | // InternalSolverLanguageParser.g:182:4: this_ScopeDefinition_8= ruleScopeDefinition | ||
| 493 | { | ||
| 413 | 494 | ||
| 414 | } | 495 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); |
| 496 | |||
| 497 | pushFollow(FOLLOW_4); | ||
| 498 | this_ScopeDefinition_8=ruleScopeDefinition(); | ||
| 415 | 499 | ||
| 416 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_5); | 500 | state._fsp--; |
| 417 | 501 | ||
| 418 | current.merge(this_INT_1); | ||
| 419 | |||
| 420 | 502 | ||
| 421 | newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); | 503 | current = this_ScopeDefinition_8; |
| 422 | 504 | afterParserOrEnumRuleCall(); | |
| 423 | kw=(Token)match(input,12,FOLLOW_4); | 505 | |
| 424 | 506 | ||
| 425 | current.merge(kw); | 507 | } |
| 426 | newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); | 508 | break; |
| 427 | 509 | case 10 : | |
| 428 | this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2); | 510 | // InternalSolverLanguageParser.g:191:4: this_ObjectiveDefinition_9= ruleObjectiveDefinition |
| 511 | { | ||
| 429 | 512 | ||
| 430 | current.merge(this_INT_3); | 513 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); |
| 431 | 514 | ||
| 515 | pushFollow(FOLLOW_4); | ||
| 516 | this_ObjectiveDefinition_9=ruleObjectiveDefinition(); | ||
| 517 | |||
| 518 | state._fsp--; | ||
| 519 | |||
| 520 | |||
| 521 | current = this_ObjectiveDefinition_9; | ||
| 522 | afterParserOrEnumRuleCall(); | ||
| 523 | |||
| 524 | |||
| 525 | } | ||
| 526 | break; | ||
| 527 | |||
| 528 | } | ||
| 529 | |||
| 530 | this_FULL_STOP_10=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
| 432 | 531 | ||
| 433 | newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); | 532 | newLeafNode(this_FULL_STOP_10, grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); |
| 434 | 533 | ||
| 435 | 534 | ||
| 436 | } | 535 | } |
| @@ -451,28 +550,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 451 | } | 550 | } |
| 452 | return current; | 551 | return current; |
| 453 | } | 552 | } |
| 454 | // $ANTLR end "ruleREALLiteral" | 553 | // $ANTLR end "ruleStatement" |
| 455 | 554 | ||
| 456 | 555 | ||
| 457 | // $ANTLR start "entryRuleINTLiteral" | 556 | // $ANTLR start "entryRuleAssertionOrDefinition" |
| 458 | // InternalSolverLanguage.g:181:1: entryRuleINTLiteral returns [String current=null] : iv_ruleINTLiteral= ruleINTLiteral EOF ; | 557 | // InternalSolverLanguageParser.g:208:1: entryRuleAssertionOrDefinition returns [EObject current=null] : iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ; |
| 459 | public final String entryRuleINTLiteral() throws RecognitionException { | 558 | public final EObject entryRuleAssertionOrDefinition() throws RecognitionException { |
| 460 | String current = null; | 559 | EObject current = null; |
| 461 | 560 | ||
| 462 | AntlrDatatypeRuleToken iv_ruleINTLiteral = null; | 561 | EObject iv_ruleAssertionOrDefinition = null; |
| 463 | 562 | ||
| 464 | 563 | ||
| 465 | try { | 564 | try { |
| 466 | // InternalSolverLanguage.g:181:50: (iv_ruleINTLiteral= ruleINTLiteral EOF ) | 565 | // InternalSolverLanguageParser.g:208:62: (iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ) |
| 467 | // InternalSolverLanguage.g:182:2: iv_ruleINTLiteral= ruleINTLiteral EOF | 566 | // InternalSolverLanguageParser.g:209:2: iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF |
| 468 | { | 567 | { |
| 469 | newCompositeNode(grammarAccess.getINTLiteralRule()); | 568 | newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); |
| 470 | pushFollow(FOLLOW_1); | 569 | pushFollow(FOLLOW_1); |
| 471 | iv_ruleINTLiteral=ruleINTLiteral(); | 570 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition(); |
| 472 | 571 | ||
| 473 | state._fsp--; | 572 | state._fsp--; |
| 474 | 573 | ||
| 475 | current =iv_ruleINTLiteral.getText(); | 574 | current =iv_ruleAssertionOrDefinition; |
| 476 | match(input,EOF,FOLLOW_2); | 575 | match(input,EOF,FOLLOW_2); |
| 477 | 576 | ||
| 478 | } | 577 | } |
| @@ -487,191 +586,258 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 487 | } | 586 | } |
| 488 | return current; | 587 | return current; |
| 489 | } | 588 | } |
| 490 | // $ANTLR end "entryRuleINTLiteral" | 589 | // $ANTLR end "entryRuleAssertionOrDefinition" |
| 491 | 590 | ||
| 492 | 591 | ||
| 493 | // $ANTLR start "ruleINTLiteral" | 592 | // $ANTLR start "ruleAssertionOrDefinition" |
| 494 | // InternalSolverLanguage.g:188:1: ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ; | 593 | // InternalSolverLanguageParser.g:215:1: ruleAssertionOrDefinition returns [EObject current=null] : (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) ; |
| 495 | public final AntlrDatatypeRuleToken ruleINTLiteral() throws RecognitionException { | 594 | public final EObject ruleAssertionOrDefinition() throws RecognitionException { |
| 496 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 595 | EObject current = null; |
| 596 | |||
| 597 | Token otherlv_2=null; | ||
| 598 | Token otherlv_5=null; | ||
| 599 | Token otherlv_8=null; | ||
| 600 | EObject this_Expression_0 = null; | ||
| 601 | |||
| 602 | EObject lv_range_3_0 = null; | ||
| 603 | |||
| 604 | EObject lv_body_6_0 = null; | ||
| 605 | |||
| 606 | EObject lv_body_9_0 = null; | ||
| 497 | 607 | ||
| 498 | Token kw=null; | ||
| 499 | Token this_INT_1=null; | ||
| 500 | 608 | ||
| 501 | 609 | ||
| 502 | enterRule(); | 610 | enterRule(); |
| 503 | 611 | ||
| 504 | try { | 612 | try { |
| 505 | // InternalSolverLanguage.g:194:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) ) | 613 | // InternalSolverLanguageParser.g:221:2: ( (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) ) |
| 506 | // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | 614 | // InternalSolverLanguageParser.g:222:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
| 507 | { | 615 | { |
| 508 | // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) | 616 | // InternalSolverLanguageParser.g:222:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
| 509 | // InternalSolverLanguage.g:196:3: (kw= '-' )? this_INT_1= RULE_INT | 617 | // InternalSolverLanguageParser.g:223:3: this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) |
| 510 | { | 618 | { |
| 511 | // InternalSolverLanguage.g:196:3: (kw= '-' )? | ||
| 512 | int alt4=2; | ||
| 513 | int LA4_0 = input.LA(1); | ||
| 514 | 619 | ||
| 515 | if ( (LA4_0==11) ) { | 620 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
| 621 | |||
| 622 | pushFollow(FOLLOW_5); | ||
| 623 | this_Expression_0=ruleExpression(); | ||
| 624 | |||
| 625 | state._fsp--; | ||
| 626 | |||
| 627 | |||
| 628 | current = this_Expression_0; | ||
| 629 | afterParserOrEnumRuleCall(); | ||
| 630 | |||
| 631 | // InternalSolverLanguageParser.g:231:3: ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) | ||
| 632 | int alt4=3; | ||
| 633 | switch ( input.LA(1) ) { | ||
| 634 | case EOF: | ||
| 635 | case Colon: | ||
| 636 | case RULE_FULL_STOP: | ||
| 637 | { | ||
| 516 | alt4=1; | 638 | alt4=1; |
| 639 | } | ||
| 640 | break; | ||
| 641 | case ColonHyphenMinus: | ||
| 642 | { | ||
| 643 | alt4=2; | ||
| 644 | } | ||
| 645 | break; | ||
| 646 | case EqualsSign: | ||
| 647 | { | ||
| 648 | alt4=3; | ||
| 649 | } | ||
| 650 | break; | ||
| 651 | default: | ||
| 652 | NoViableAltException nvae = | ||
| 653 | new NoViableAltException("", 4, 0, input); | ||
| 654 | |||
| 655 | throw nvae; | ||
| 517 | } | 656 | } |
| 657 | |||
| 518 | switch (alt4) { | 658 | switch (alt4) { |
| 519 | case 1 : | 659 | case 1 : |
| 520 | // InternalSolverLanguage.g:197:4: kw= '-' | 660 | // InternalSolverLanguageParser.g:232:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) |
| 661 | { | ||
| 662 | // InternalSolverLanguageParser.g:232:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ||
| 663 | // InternalSolverLanguageParser.g:233:5: () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? | ||
| 664 | { | ||
| 665 | // InternalSolverLanguageParser.g:233:5: () | ||
| 666 | // InternalSolverLanguageParser.g:234:6: | ||
| 521 | { | 667 | { |
| 522 | kw=(Token)match(input,11,FOLLOW_4); | ||
| 523 | 668 | ||
| 524 | current.merge(kw); | 669 | current = forceCreateModelElementAndSet( |
| 525 | newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); | 670 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), |
| 526 | 671 | current); | |
| 672 | |||
| 527 | 673 | ||
| 528 | } | 674 | } |
| 529 | break; | ||
| 530 | 675 | ||
| 531 | } | 676 | // InternalSolverLanguageParser.g:240:5: (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? |
| 677 | int alt3=2; | ||
| 678 | int LA3_0 = input.LA(1); | ||
| 532 | 679 | ||
| 533 | this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2); | 680 | if ( (LA3_0==Colon) ) { |
| 681 | alt3=1; | ||
| 682 | } | ||
| 683 | switch (alt3) { | ||
| 684 | case 1 : | ||
| 685 | // InternalSolverLanguageParser.g:241:6: otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) | ||
| 686 | { | ||
| 687 | otherlv_2=(Token)match(input,Colon,FOLLOW_6); | ||
| 534 | 688 | ||
| 535 | current.merge(this_INT_1); | 689 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
| 536 | 690 | ||
| 691 | // InternalSolverLanguageParser.g:245:6: ( (lv_range_3_0= ruleExpression ) ) | ||
| 692 | // InternalSolverLanguageParser.g:246:7: (lv_range_3_0= ruleExpression ) | ||
| 693 | { | ||
| 694 | // InternalSolverLanguageParser.g:246:7: (lv_range_3_0= ruleExpression ) | ||
| 695 | // InternalSolverLanguageParser.g:247:8: lv_range_3_0= ruleExpression | ||
| 696 | { | ||
| 537 | 697 | ||
| 538 | newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); | 698 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); |
| 539 | 699 | ||
| 700 | pushFollow(FOLLOW_2); | ||
| 701 | lv_range_3_0=ruleExpression(); | ||
| 540 | 702 | ||
| 541 | } | 703 | state._fsp--; |
| 542 | 704 | ||
| 543 | 705 | ||
| 544 | } | 706 | if (current==null) { |
| 707 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 708 | } | ||
| 709 | set( | ||
| 710 | current, | ||
| 711 | "range", | ||
| 712 | lv_range_3_0, | ||
| 713 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 714 | afterParserOrEnumRuleCall(); | ||
| 715 | |||
| 545 | 716 | ||
| 717 | } | ||
| 546 | 718 | ||
| 547 | leaveRule(); | ||
| 548 | 719 | ||
| 549 | } | 720 | } |
| 550 | 721 | ||
| 551 | catch (RecognitionException re) { | ||
| 552 | recover(input,re); | ||
| 553 | appendSkippedTokens(); | ||
| 554 | } | ||
| 555 | finally { | ||
| 556 | } | ||
| 557 | return current; | ||
| 558 | } | ||
| 559 | // $ANTLR end "ruleINTLiteral" | ||
| 560 | 722 | ||
| 723 | } | ||
| 724 | break; | ||
| 561 | 725 | ||
| 562 | // $ANTLR start "entryRuleBooleanValue" | 726 | } |
| 563 | // InternalSolverLanguage.g:214:1: entryRuleBooleanValue returns [EObject current=null] : iv_ruleBooleanValue= ruleBooleanValue EOF ; | ||
| 564 | public final EObject entryRuleBooleanValue() throws RecognitionException { | ||
| 565 | EObject current = null; | ||
| 566 | 727 | ||
| 567 | EObject iv_ruleBooleanValue = null; | ||
| 568 | 728 | ||
| 729 | } | ||
| 569 | 730 | ||
| 570 | try { | ||
| 571 | // InternalSolverLanguage.g:214:53: (iv_ruleBooleanValue= ruleBooleanValue EOF ) | ||
| 572 | // InternalSolverLanguage.g:215:2: iv_ruleBooleanValue= ruleBooleanValue EOF | ||
| 573 | { | ||
| 574 | newCompositeNode(grammarAccess.getBooleanValueRule()); | ||
| 575 | pushFollow(FOLLOW_1); | ||
| 576 | iv_ruleBooleanValue=ruleBooleanValue(); | ||
| 577 | 731 | ||
| 578 | state._fsp--; | 732 | } |
| 733 | break; | ||
| 734 | case 2 : | ||
| 735 | // InternalSolverLanguageParser.g:267:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ||
| 736 | { | ||
| 737 | // InternalSolverLanguageParser.g:267:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ||
| 738 | // InternalSolverLanguageParser.g:268:5: () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) | ||
| 739 | { | ||
| 740 | // InternalSolverLanguageParser.g:268:5: () | ||
| 741 | // InternalSolverLanguageParser.g:269:6: | ||
| 742 | { | ||
| 579 | 743 | ||
| 580 | current =iv_ruleBooleanValue; | 744 | current = forceCreateModelElementAndSet( |
| 581 | match(input,EOF,FOLLOW_2); | 745 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), |
| 746 | current); | ||
| 747 | |||
| 582 | 748 | ||
| 583 | } | 749 | } |
| 584 | 750 | ||
| 585 | } | 751 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_6); |
| 586 | 752 | ||
| 587 | catch (RecognitionException re) { | 753 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
| 588 | recover(input,re); | 754 | |
| 589 | appendSkippedTokens(); | 755 | // InternalSolverLanguageParser.g:279:5: ( (lv_body_6_0= ruleExpression ) ) |
| 590 | } | 756 | // InternalSolverLanguageParser.g:280:6: (lv_body_6_0= ruleExpression ) |
| 591 | finally { | 757 | { |
| 592 | } | 758 | // InternalSolverLanguageParser.g:280:6: (lv_body_6_0= ruleExpression ) |
| 593 | return current; | 759 | // InternalSolverLanguageParser.g:281:7: lv_body_6_0= ruleExpression |
| 594 | } | 760 | { |
| 595 | // $ANTLR end "entryRuleBooleanValue" | ||
| 596 | 761 | ||
| 762 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
| 763 | |||
| 764 | pushFollow(FOLLOW_2); | ||
| 765 | lv_body_6_0=ruleExpression(); | ||
| 597 | 766 | ||
| 598 | // $ANTLR start "ruleBooleanValue" | 767 | state._fsp--; |
| 599 | // InternalSolverLanguage.g:221:1: ruleBooleanValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ; | ||
| 600 | public final EObject ruleBooleanValue() throws RecognitionException { | ||
| 601 | EObject current = null; | ||
| 602 | 768 | ||
| 603 | Token otherlv_1=null; | ||
| 604 | Token otherlv_2=null; | ||
| 605 | 769 | ||
| 770 | if (current==null) { | ||
| 771 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
| 772 | } | ||
| 773 | set( | ||
| 774 | current, | ||
| 775 | "body", | ||
| 776 | lv_body_6_0, | ||
| 777 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 778 | afterParserOrEnumRuleCall(); | ||
| 779 | |||
| 606 | 780 | ||
| 607 | enterRule(); | 781 | } |
| 608 | 782 | ||
| 609 | try { | ||
| 610 | // InternalSolverLanguage.g:227:2: ( ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ) | ||
| 611 | // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) | ||
| 612 | { | ||
| 613 | // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) | ||
| 614 | int alt5=2; | ||
| 615 | int LA5_0 = input.LA(1); | ||
| 616 | 783 | ||
| 617 | if ( (LA5_0==13) ) { | 784 | } |
| 618 | alt5=1; | ||
| 619 | } | ||
| 620 | else if ( (LA5_0==14) ) { | ||
| 621 | alt5=2; | ||
| 622 | } | ||
| 623 | else { | ||
| 624 | NoViableAltException nvae = | ||
| 625 | new NoViableAltException("", 5, 0, input); | ||
| 626 | 785 | ||
| 627 | throw nvae; | 786 | |
| 628 | } | 787 | } |
| 629 | switch (alt5) { | 788 | |
| 630 | case 1 : | 789 | |
| 631 | // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) | 790 | } |
| 791 | break; | ||
| 792 | case 3 : | ||
| 793 | // InternalSolverLanguageParser.g:300:4: ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) | ||
| 632 | { | 794 | { |
| 633 | // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) | 795 | // InternalSolverLanguageParser.g:300:4: ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) |
| 634 | // InternalSolverLanguage.g:230:4: () otherlv_1= 'true' | 796 | // InternalSolverLanguageParser.g:301:5: () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) |
| 635 | { | 797 | { |
| 636 | // InternalSolverLanguage.g:230:4: () | 798 | // InternalSolverLanguageParser.g:301:5: () |
| 637 | // InternalSolverLanguage.g:231:5: | 799 | // InternalSolverLanguageParser.g:302:6: |
| 638 | { | 800 | { |
| 639 | 801 | ||
| 640 | current = forceCreateModelElement( | 802 | current = forceCreateModelElementAndSet( |
| 641 | grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), | 803 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), |
| 642 | current); | 804 | current); |
| 643 | 805 | ||
| 644 | 806 | ||
| 645 | } | 807 | } |
| 646 | 808 | ||
| 647 | otherlv_1=(Token)match(input,13,FOLLOW_2); | 809 | otherlv_8=(Token)match(input,EqualsSign,FOLLOW_6); |
| 648 | 810 | ||
| 649 | newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); | 811 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); |
| 650 | 812 | ||
| 813 | // InternalSolverLanguageParser.g:312:5: ( (lv_body_9_0= ruleExpression ) ) | ||
| 814 | // InternalSolverLanguageParser.g:313:6: (lv_body_9_0= ruleExpression ) | ||
| 815 | { | ||
| 816 | // InternalSolverLanguageParser.g:313:6: (lv_body_9_0= ruleExpression ) | ||
| 817 | // InternalSolverLanguageParser.g:314:7: lv_body_9_0= ruleExpression | ||
| 818 | { | ||
| 651 | 819 | ||
| 652 | } | 820 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); |
| 821 | |||
| 822 | pushFollow(FOLLOW_2); | ||
| 823 | lv_body_9_0=ruleExpression(); | ||
| 653 | 824 | ||
| 825 | state._fsp--; | ||
| 654 | 826 | ||
| 655 | } | ||
| 656 | break; | ||
| 657 | case 2 : | ||
| 658 | // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) | ||
| 659 | { | ||
| 660 | // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) | ||
| 661 | // InternalSolverLanguage.g:244:4: otherlv_2= 'false' () | ||
| 662 | { | ||
| 663 | otherlv_2=(Token)match(input,14,FOLLOW_2); | ||
| 664 | 827 | ||
| 665 | newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); | 828 | if (current==null) { |
| 666 | 829 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | |
| 667 | // InternalSolverLanguage.g:248:4: () | 830 | } |
| 668 | // InternalSolverLanguage.g:249:5: | 831 | set( |
| 669 | { | 832 | current, |
| 833 | "body", | ||
| 834 | lv_body_9_0, | ||
| 835 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 836 | afterParserOrEnumRuleCall(); | ||
| 837 | |||
| 838 | |||
| 839 | } | ||
| 670 | 840 | ||
| 671 | current = forceCreateModelElement( | ||
| 672 | grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), | ||
| 673 | current); | ||
| 674 | |||
| 675 | 841 | ||
| 676 | } | 842 | } |
| 677 | 843 | ||
| @@ -688,6 +854,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 688 | } | 854 | } |
| 689 | 855 | ||
| 690 | 856 | ||
| 857 | } | ||
| 858 | |||
| 859 | |||
| 691 | leaveRule(); | 860 | leaveRule(); |
| 692 | 861 | ||
| 693 | } | 862 | } |
| @@ -700,28 +869,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 700 | } | 869 | } |
| 701 | return current; | 870 | return current; |
| 702 | } | 871 | } |
| 703 | // $ANTLR end "ruleBooleanValue" | 872 | // $ANTLR end "ruleAssertionOrDefinition" |
| 704 | 873 | ||
| 705 | 874 | ||
| 706 | // $ANTLR start "entryRuleTruthValue" | 875 | // $ANTLR start "entryRulePredicateDefinition" |
| 707 | // InternalSolverLanguage.g:260:1: entryRuleTruthValue returns [EObject current=null] : iv_ruleTruthValue= ruleTruthValue EOF ; | 876 | // InternalSolverLanguageParser.g:337:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; |
| 708 | public final EObject entryRuleTruthValue() throws RecognitionException { | 877 | public final EObject entryRulePredicateDefinition() throws RecognitionException { |
| 709 | EObject current = null; | 878 | EObject current = null; |
| 710 | 879 | ||
| 711 | EObject iv_ruleTruthValue = null; | 880 | EObject iv_rulePredicateDefinition = null; |
| 712 | 881 | ||
| 713 | 882 | ||
| 714 | try { | 883 | try { |
| 715 | // InternalSolverLanguage.g:260:51: (iv_ruleTruthValue= ruleTruthValue EOF ) | 884 | // InternalSolverLanguageParser.g:337:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) |
| 716 | // InternalSolverLanguage.g:261:2: iv_ruleTruthValue= ruleTruthValue EOF | 885 | // InternalSolverLanguageParser.g:338:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF |
| 717 | { | 886 | { |
| 718 | newCompositeNode(grammarAccess.getTruthValueRule()); | 887 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); |
| 719 | pushFollow(FOLLOW_1); | 888 | pushFollow(FOLLOW_1); |
| 720 | iv_ruleTruthValue=ruleTruthValue(); | 889 | iv_rulePredicateDefinition=rulePredicateDefinition(); |
| 721 | 890 | ||
| 722 | state._fsp--; | 891 | state._fsp--; |
| 723 | 892 | ||
| 724 | current =iv_ruleTruthValue; | 893 | current =iv_rulePredicateDefinition; |
| 725 | match(input,EOF,FOLLOW_2); | 894 | match(input,EOF,FOLLOW_2); |
| 726 | 895 | ||
| 727 | } | 896 | } |
| @@ -736,159 +905,179 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 736 | } | 905 | } |
| 737 | return current; | 906 | return current; |
| 738 | } | 907 | } |
| 739 | // $ANTLR end "entryRuleTruthValue" | 908 | // $ANTLR end "entryRulePredicateDefinition" |
| 740 | 909 | ||
| 741 | 910 | ||
| 742 | // $ANTLR start "ruleTruthValue" | 911 | // $ANTLR start "rulePredicateDefinition" |
| 743 | // InternalSolverLanguage.g:267:1: ruleTruthValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ; | 912 | // InternalSolverLanguageParser.g:344:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) ; |
| 744 | public final EObject ruleTruthValue() throws RecognitionException { | 913 | public final EObject rulePredicateDefinition() throws RecognitionException { |
| 745 | EObject current = null; | 914 | EObject current = null; |
| 746 | 915 | ||
| 747 | Token otherlv_1=null; | 916 | Token lv_functional_0_0=null; |
| 748 | Token otherlv_3=null; | 917 | Token lv_error_1_0=null; |
| 918 | Token lv_error_2_0=null; | ||
| 919 | Token lv_functional_3_0=null; | ||
| 749 | Token otherlv_5=null; | 920 | Token otherlv_5=null; |
| 750 | Token otherlv_7=null; | 921 | EObject lv_head_4_0 = null; |
| 922 | |||
| 923 | EObject lv_body_6_0 = null; | ||
| 924 | |||
| 751 | 925 | ||
| 752 | 926 | ||
| 753 | enterRule(); | 927 | enterRule(); |
| 754 | 928 | ||
| 755 | try { | 929 | try { |
| 756 | // InternalSolverLanguage.g:273:2: ( ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ) | 930 | // InternalSolverLanguageParser.g:350:2: ( ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) ) |
| 757 | // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) | 931 | // InternalSolverLanguageParser.g:351:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
| 758 | { | 932 | { |
| 759 | // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) | 933 | // InternalSolverLanguageParser.g:351:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
| 760 | int alt6=4; | 934 | // InternalSolverLanguageParser.g:352:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) |
| 761 | switch ( input.LA(1) ) { | 935 | { |
| 762 | case 13: | 936 | // InternalSolverLanguageParser.g:352:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) |
| 763 | { | 937 | int alt7=2; |
| 764 | alt6=1; | 938 | int LA7_0 = input.LA(1); |
| 765 | } | 939 | |
| 766 | break; | 940 | if ( (LA7_0==Functional) ) { |
| 767 | case 14: | 941 | alt7=1; |
| 768 | { | 942 | } |
| 769 | alt6=2; | 943 | else if ( (LA7_0==Error) ) { |
| 770 | } | 944 | alt7=2; |
| 771 | break; | 945 | } |
| 772 | case 15: | 946 | else { |
| 773 | { | ||
| 774 | alt6=3; | ||
| 775 | } | ||
| 776 | break; | ||
| 777 | case 16: | ||
| 778 | { | ||
| 779 | alt6=4; | ||
| 780 | } | ||
| 781 | break; | ||
| 782 | default: | ||
| 783 | NoViableAltException nvae = | 947 | NoViableAltException nvae = |
| 784 | new NoViableAltException("", 6, 0, input); | 948 | new NoViableAltException("", 7, 0, input); |
| 785 | 949 | ||
| 786 | throw nvae; | 950 | throw nvae; |
| 787 | } | 951 | } |
| 788 | 952 | switch (alt7) { | |
| 789 | switch (alt6) { | ||
| 790 | case 1 : | 953 | case 1 : |
| 791 | // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) | 954 | // InternalSolverLanguageParser.g:353:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) |
| 955 | { | ||
| 956 | // InternalSolverLanguageParser.g:353:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ||
| 957 | // InternalSolverLanguageParser.g:354:5: ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? | ||
| 792 | { | 958 | { |
| 793 | // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) | 959 | // InternalSolverLanguageParser.g:354:5: ( (lv_functional_0_0= Functional ) ) |
| 794 | // InternalSolverLanguage.g:276:4: () otherlv_1= 'true' | 960 | // InternalSolverLanguageParser.g:355:6: (lv_functional_0_0= Functional ) |
| 795 | { | 961 | { |
| 796 | // InternalSolverLanguage.g:276:4: () | 962 | // InternalSolverLanguageParser.g:355:6: (lv_functional_0_0= Functional ) |
| 797 | // InternalSolverLanguage.g:277:5: | 963 | // InternalSolverLanguageParser.g:356:7: lv_functional_0_0= Functional |
| 798 | { | 964 | { |
| 965 | lv_functional_0_0=(Token)match(input,Functional,FOLLOW_7); | ||
| 799 | 966 | ||
| 800 | current = forceCreateModelElement( | 967 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
| 801 | grammarAccess.getTruthValueAccess().getTrueAction_0_0(), | 968 | |
| 802 | current); | ||
| 803 | |||
| 804 | 969 | ||
| 805 | } | 970 | if (current==null) { |
| 971 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 972 | } | ||
| 973 | setWithLastConsumed(current, "functional", true, "functional"); | ||
| 974 | |||
| 806 | 975 | ||
| 807 | otherlv_1=(Token)match(input,13,FOLLOW_2); | 976 | } |
| 808 | 977 | ||
| 809 | newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); | ||
| 810 | |||
| 811 | 978 | ||
| 812 | } | 979 | } |
| 813 | 980 | ||
| 981 | // InternalSolverLanguageParser.g:368:5: ( (lv_error_1_0= Error ) )? | ||
| 982 | int alt5=2; | ||
| 983 | int LA5_0 = input.LA(1); | ||
| 814 | 984 | ||
| 985 | if ( (LA5_0==Error) ) { | ||
| 986 | alt5=1; | ||
| 815 | } | 987 | } |
| 816 | break; | 988 | switch (alt5) { |
| 817 | case 2 : | 989 | case 1 : |
| 818 | // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) | 990 | // InternalSolverLanguageParser.g:369:6: (lv_error_1_0= Error ) |
| 819 | { | 991 | { |
| 820 | // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) | 992 | // InternalSolverLanguageParser.g:369:6: (lv_error_1_0= Error ) |
| 821 | // InternalSolverLanguage.g:290:4: () otherlv_3= 'false' | 993 | // InternalSolverLanguageParser.g:370:7: lv_error_1_0= Error |
| 822 | { | 994 | { |
| 823 | // InternalSolverLanguage.g:290:4: () | 995 | lv_error_1_0=(Token)match(input,Error,FOLLOW_8); |
| 824 | // InternalSolverLanguage.g:291:5: | ||
| 825 | { | ||
| 826 | 996 | ||
| 827 | current = forceCreateModelElement( | 997 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
| 828 | grammarAccess.getTruthValueAccess().getFalseAction_1_0(), | 998 | |
| 829 | current); | ||
| 830 | |||
| 831 | 999 | ||
| 832 | } | 1000 | if (current==null) { |
| 1001 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1002 | } | ||
| 1003 | setWithLastConsumed(current, "error", true, "error"); | ||
| 1004 | |||
| 1005 | |||
| 1006 | } | ||
| 833 | 1007 | ||
| 834 | otherlv_3=(Token)match(input,14,FOLLOW_2); | ||
| 835 | 1008 | ||
| 836 | newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); | 1009 | } |
| 837 | 1010 | break; | |
| 1011 | |||
| 1012 | } | ||
| 1013 | |||
| 838 | 1014 | ||
| 839 | } | 1015 | } |
| 840 | 1016 | ||
| 841 | 1017 | ||
| 842 | } | 1018 | } |
| 843 | break; | 1019 | break; |
| 844 | case 3 : | 1020 | case 2 : |
| 845 | // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) | 1021 | // InternalSolverLanguageParser.g:384:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) |
| 846 | { | 1022 | { |
| 847 | // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) | 1023 | // InternalSolverLanguageParser.g:384:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) |
| 848 | // InternalSolverLanguage.g:304:4: () otherlv_5= 'unknown' | 1024 | // InternalSolverLanguageParser.g:385:5: ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? |
| 849 | { | 1025 | { |
| 850 | // InternalSolverLanguage.g:304:4: () | 1026 | // InternalSolverLanguageParser.g:385:5: ( (lv_error_2_0= Error ) ) |
| 851 | // InternalSolverLanguage.g:305:5: | 1027 | // InternalSolverLanguageParser.g:386:6: (lv_error_2_0= Error ) |
| 852 | { | 1028 | { |
| 1029 | // InternalSolverLanguageParser.g:386:6: (lv_error_2_0= Error ) | ||
| 1030 | // InternalSolverLanguageParser.g:387:7: lv_error_2_0= Error | ||
| 1031 | { | ||
| 1032 | lv_error_2_0=(Token)match(input,Error,FOLLOW_9); | ||
| 853 | 1033 | ||
| 854 | current = forceCreateModelElement( | 1034 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
| 855 | grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), | 1035 | |
| 856 | current); | ||
| 857 | |||
| 858 | 1036 | ||
| 859 | } | 1037 | if (current==null) { |
| 1038 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1039 | } | ||
| 1040 | setWithLastConsumed(current, "error", true, "error"); | ||
| 1041 | |||
| 860 | 1042 | ||
| 861 | otherlv_5=(Token)match(input,15,FOLLOW_2); | 1043 | } |
| 862 | 1044 | ||
| 863 | newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); | ||
| 864 | |||
| 865 | 1045 | ||
| 866 | } | 1046 | } |
| 867 | 1047 | ||
| 1048 | // InternalSolverLanguageParser.g:399:5: ( (lv_functional_3_0= Functional ) )? | ||
| 1049 | int alt6=2; | ||
| 1050 | int LA6_0 = input.LA(1); | ||
| 868 | 1051 | ||
| 1052 | if ( (LA6_0==Functional) ) { | ||
| 1053 | alt6=1; | ||
| 869 | } | 1054 | } |
| 870 | break; | 1055 | switch (alt6) { |
| 871 | case 4 : | 1056 | case 1 : |
| 872 | // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) | 1057 | // InternalSolverLanguageParser.g:400:6: (lv_functional_3_0= Functional ) |
| 873 | { | 1058 | { |
| 874 | // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) | 1059 | // InternalSolverLanguageParser.g:400:6: (lv_functional_3_0= Functional ) |
| 875 | // InternalSolverLanguage.g:318:4: () otherlv_7= 'error' | 1060 | // InternalSolverLanguageParser.g:401:7: lv_functional_3_0= Functional |
| 876 | { | 1061 | { |
| 877 | // InternalSolverLanguage.g:318:4: () | 1062 | lv_functional_3_0=(Token)match(input,Functional,FOLLOW_8); |
| 878 | // InternalSolverLanguage.g:319:5: | ||
| 879 | { | ||
| 880 | 1063 | ||
| 881 | current = forceCreateModelElement( | 1064 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
| 882 | grammarAccess.getTruthValueAccess().getErrorAction_3_0(), | 1065 | |
| 883 | current); | ||
| 884 | |||
| 885 | 1066 | ||
| 886 | } | 1067 | if (current==null) { |
| 1068 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
| 1069 | } | ||
| 1070 | setWithLastConsumed(current, "functional", true, "functional"); | ||
| 1071 | |||
| 887 | 1072 | ||
| 888 | otherlv_7=(Token)match(input,16,FOLLOW_2); | 1073 | } |
| 1074 | |||
| 1075 | |||
| 1076 | } | ||
| 1077 | break; | ||
| 1078 | |||
| 1079 | } | ||
| 889 | 1080 | ||
| 890 | newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); | ||
| 891 | |||
| 892 | 1081 | ||
| 893 | } | 1082 | } |
| 894 | 1083 | ||
| @@ -898,6 +1087,75 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 898 | 1087 | ||
| 899 | } | 1088 | } |
| 900 | 1089 | ||
| 1090 | // InternalSolverLanguageParser.g:415:3: ( (lv_head_4_0= ruleCall ) ) | ||
| 1091 | // InternalSolverLanguageParser.g:416:4: (lv_head_4_0= ruleCall ) | ||
| 1092 | { | ||
| 1093 | // InternalSolverLanguageParser.g:416:4: (lv_head_4_0= ruleCall ) | ||
| 1094 | // InternalSolverLanguageParser.g:417:5: lv_head_4_0= ruleCall | ||
| 1095 | { | ||
| 1096 | |||
| 1097 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
| 1098 | |||
| 1099 | pushFollow(FOLLOW_10); | ||
| 1100 | lv_head_4_0=ruleCall(); | ||
| 1101 | |||
| 1102 | state._fsp--; | ||
| 1103 | |||
| 1104 | |||
| 1105 | if (current==null) { | ||
| 1106 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 1107 | } | ||
| 1108 | set( | ||
| 1109 | current, | ||
| 1110 | "head", | ||
| 1111 | lv_head_4_0, | ||
| 1112 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 1113 | afterParserOrEnumRuleCall(); | ||
| 1114 | |||
| 1115 | |||
| 1116 | } | ||
| 1117 | |||
| 1118 | |||
| 1119 | } | ||
| 1120 | |||
| 1121 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_6); | ||
| 1122 | |||
| 1123 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 1124 | |||
| 1125 | // InternalSolverLanguageParser.g:438:3: ( (lv_body_6_0= ruleExpression ) ) | ||
| 1126 | // InternalSolverLanguageParser.g:439:4: (lv_body_6_0= ruleExpression ) | ||
| 1127 | { | ||
| 1128 | // InternalSolverLanguageParser.g:439:4: (lv_body_6_0= ruleExpression ) | ||
| 1129 | // InternalSolverLanguageParser.g:440:5: lv_body_6_0= ruleExpression | ||
| 1130 | { | ||
| 1131 | |||
| 1132 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
| 1133 | |||
| 1134 | pushFollow(FOLLOW_2); | ||
| 1135 | lv_body_6_0=ruleExpression(); | ||
| 1136 | |||
| 1137 | state._fsp--; | ||
| 1138 | |||
| 1139 | |||
| 1140 | if (current==null) { | ||
| 1141 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
| 1142 | } | ||
| 1143 | set( | ||
| 1144 | current, | ||
| 1145 | "body", | ||
| 1146 | lv_body_6_0, | ||
| 1147 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1148 | afterParserOrEnumRuleCall(); | ||
| 1149 | |||
| 1150 | |||
| 1151 | } | ||
| 1152 | |||
| 1153 | |||
| 1154 | } | ||
| 1155 | |||
| 1156 | |||
| 1157 | } | ||
| 1158 | |||
| 901 | 1159 | ||
| 902 | } | 1160 | } |
| 903 | 1161 | ||
| @@ -914,28 +1172,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 914 | } | 1172 | } |
| 915 | return current; | 1173 | return current; |
| 916 | } | 1174 | } |
| 917 | // $ANTLR end "ruleTruthValue" | 1175 | // $ANTLR end "rulePredicateDefinition" |
| 918 | 1176 | ||
| 919 | 1177 | ||
| 920 | // $ANTLR start "entryRuleInterpretation" | 1178 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" |
| 921 | // InternalSolverLanguage.g:334:1: entryRuleInterpretation returns [EObject current=null] : iv_ruleInterpretation= ruleInterpretation EOF ; | 1179 | // InternalSolverLanguageParser.g:461:1: entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null] : iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ; |
| 922 | public final EObject entryRuleInterpretation() throws RecognitionException { | 1180 | public final EObject entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { |
| 923 | EObject current = null; | 1181 | EObject current = null; |
| 924 | 1182 | ||
| 925 | EObject iv_ruleInterpretation = null; | 1183 | EObject iv_ruleUnnamedErrorPrediateDefinition = null; |
| 926 | 1184 | ||
| 927 | 1185 | ||
| 928 | try { | 1186 | try { |
| 929 | // InternalSolverLanguage.g:334:55: (iv_ruleInterpretation= ruleInterpretation EOF ) | 1187 | // InternalSolverLanguageParser.g:461:71: (iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ) |
| 930 | // InternalSolverLanguage.g:335:2: iv_ruleInterpretation= ruleInterpretation EOF | 1188 | // InternalSolverLanguageParser.g:462:2: iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF |
| 931 | { | 1189 | { |
| 932 | newCompositeNode(grammarAccess.getInterpretationRule()); | 1190 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
| 933 | pushFollow(FOLLOW_1); | 1191 | pushFollow(FOLLOW_1); |
| 934 | iv_ruleInterpretation=ruleInterpretation(); | 1192 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition(); |
| 935 | 1193 | ||
| 936 | state._fsp--; | 1194 | state._fsp--; |
| 937 | 1195 | ||
| 938 | current =iv_ruleInterpretation; | 1196 | current =iv_ruleUnnamedErrorPrediateDefinition; |
| 939 | match(input,EOF,FOLLOW_2); | 1197 | match(input,EOF,FOLLOW_2); |
| 940 | 1198 | ||
| 941 | } | 1199 | } |
| @@ -950,118 +1208,101 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 950 | } | 1208 | } |
| 951 | return current; | 1209 | return current; |
| 952 | } | 1210 | } |
| 953 | // $ANTLR end "entryRuleInterpretation" | 1211 | // $ANTLR end "entryRuleUnnamedErrorPrediateDefinition" |
| 954 | 1212 | ||
| 955 | 1213 | ||
| 956 | // $ANTLR start "ruleInterpretation" | 1214 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" |
| 957 | // InternalSolverLanguage.g:341:1: ruleInterpretation returns [EObject current=null] : (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ; | 1215 | // InternalSolverLanguageParser.g:468:1: ruleUnnamedErrorPrediateDefinition returns [EObject current=null] : (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) ; |
| 958 | public final EObject ruleInterpretation() throws RecognitionException { | 1216 | public final EObject ruleUnnamedErrorPrediateDefinition() throws RecognitionException { |
| 959 | EObject current = null; | 1217 | EObject current = null; |
| 960 | 1218 | ||
| 961 | EObject this_BasicInterpretation_0 = null; | 1219 | Token otherlv_0=null; |
| 962 | 1220 | Token otherlv_2=null; | |
| 963 | EObject this_DefaultInterpretation_1 = null; | 1221 | EObject lv_argumentList_1_0 = null; |
| 964 | 1222 | ||
| 965 | EObject this_CDInterpretation_2 = null; | 1223 | EObject lv_body_3_0 = null; |
| 966 | 1224 | ||
| 967 | 1225 | ||
| 968 | 1226 | ||
| 969 | enterRule(); | 1227 | enterRule(); |
| 970 | 1228 | ||
| 971 | try { | 1229 | try { |
| 972 | // InternalSolverLanguage.g:347:2: ( (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ) | 1230 | // InternalSolverLanguageParser.g:474:2: ( (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) ) |
| 973 | // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) | 1231 | // InternalSolverLanguageParser.g:475:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) |
| 974 | { | 1232 | { |
| 975 | // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) | 1233 | // InternalSolverLanguageParser.g:475:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) |
| 976 | int alt7=3; | 1234 | // InternalSolverLanguageParser.g:476:3: otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) |
| 977 | switch ( input.LA(1) ) { | 1235 | { |
| 978 | case RULE_ID: | 1236 | otherlv_0=(Token)match(input,Error,FOLLOW_11); |
| 979 | case 21: | ||
| 980 | case 22: | ||
| 981 | case 23: | ||
| 982 | case 24: | ||
| 983 | case 25: | ||
| 984 | case 26: | ||
| 985 | { | ||
| 986 | alt7=1; | ||
| 987 | } | ||
| 988 | break; | ||
| 989 | case 32: | ||
| 990 | { | ||
| 991 | alt7=2; | ||
| 992 | } | ||
| 993 | break; | ||
| 994 | case 33: | ||
| 995 | case 34: | ||
| 996 | case 38: | ||
| 997 | case 39: | ||
| 998 | case 40: | ||
| 999 | { | ||
| 1000 | alt7=3; | ||
| 1001 | } | ||
| 1002 | break; | ||
| 1003 | default: | ||
| 1004 | NoViableAltException nvae = | ||
| 1005 | new NoViableAltException("", 7, 0, input); | ||
| 1006 | 1237 | ||
| 1007 | throw nvae; | 1238 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
| 1008 | } | 1239 | |
| 1240 | // InternalSolverLanguageParser.g:480:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) | ||
| 1241 | // InternalSolverLanguageParser.g:481:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
| 1242 | { | ||
| 1243 | // InternalSolverLanguageParser.g:481:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
| 1244 | // InternalSolverLanguageParser.g:482:5: lv_argumentList_1_0= ruleArgumentList | ||
| 1245 | { | ||
| 1009 | 1246 | ||
| 1010 | switch (alt7) { | 1247 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); |
| 1011 | case 1 : | 1248 | |
| 1012 | // InternalSolverLanguage.g:349:3: this_BasicInterpretation_0= ruleBasicInterpretation | 1249 | pushFollow(FOLLOW_10); |
| 1013 | { | 1250 | lv_argumentList_1_0=ruleArgumentList(); |
| 1014 | 1251 | ||
| 1015 | newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); | 1252 | state._fsp--; |
| 1016 | |||
| 1017 | pushFollow(FOLLOW_2); | ||
| 1018 | this_BasicInterpretation_0=ruleBasicInterpretation(); | ||
| 1019 | 1253 | ||
| 1020 | state._fsp--; | ||
| 1021 | 1254 | ||
| 1255 | if (current==null) { | ||
| 1256 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 1257 | } | ||
| 1258 | set( | ||
| 1259 | current, | ||
| 1260 | "argumentList", | ||
| 1261 | lv_argumentList_1_0, | ||
| 1262 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
| 1263 | afterParserOrEnumRuleCall(); | ||
| 1264 | |||
| 1022 | 1265 | ||
| 1023 | current = this_BasicInterpretation_0; | 1266 | } |
| 1024 | afterParserOrEnumRuleCall(); | ||
| 1025 | |||
| 1026 | 1267 | ||
| 1027 | } | ||
| 1028 | break; | ||
| 1029 | case 2 : | ||
| 1030 | // InternalSolverLanguage.g:358:3: this_DefaultInterpretation_1= ruleDefaultInterpretation | ||
| 1031 | { | ||
| 1032 | 1268 | ||
| 1033 | newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); | 1269 | } |
| 1034 | |||
| 1035 | pushFollow(FOLLOW_2); | ||
| 1036 | this_DefaultInterpretation_1=ruleDefaultInterpretation(); | ||
| 1037 | 1270 | ||
| 1038 | state._fsp--; | 1271 | otherlv_2=(Token)match(input,ColonHyphenMinus,FOLLOW_6); |
| 1039 | 1272 | ||
| 1273 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
| 1274 | |||
| 1275 | // InternalSolverLanguageParser.g:503:3: ( (lv_body_3_0= ruleExpression ) ) | ||
| 1276 | // InternalSolverLanguageParser.g:504:4: (lv_body_3_0= ruleExpression ) | ||
| 1277 | { | ||
| 1278 | // InternalSolverLanguageParser.g:504:4: (lv_body_3_0= ruleExpression ) | ||
| 1279 | // InternalSolverLanguageParser.g:505:5: lv_body_3_0= ruleExpression | ||
| 1280 | { | ||
| 1040 | 1281 | ||
| 1041 | current = this_DefaultInterpretation_1; | 1282 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
| 1042 | afterParserOrEnumRuleCall(); | 1283 | |
| 1043 | 1284 | pushFollow(FOLLOW_2); | |
| 1285 | lv_body_3_0=ruleExpression(); | ||
| 1044 | 1286 | ||
| 1045 | } | 1287 | state._fsp--; |
| 1046 | break; | ||
| 1047 | case 3 : | ||
| 1048 | // InternalSolverLanguage.g:367:3: this_CDInterpretation_2= ruleCDInterpretation | ||
| 1049 | { | ||
| 1050 | 1288 | ||
| 1051 | newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); | ||
| 1052 | |||
| 1053 | pushFollow(FOLLOW_2); | ||
| 1054 | this_CDInterpretation_2=ruleCDInterpretation(); | ||
| 1055 | 1289 | ||
| 1056 | state._fsp--; | 1290 | if (current==null) { |
| 1291 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
| 1292 | } | ||
| 1293 | set( | ||
| 1294 | current, | ||
| 1295 | "body", | ||
| 1296 | lv_body_3_0, | ||
| 1297 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1298 | afterParserOrEnumRuleCall(); | ||
| 1299 | |||
| 1057 | 1300 | ||
| 1301 | } | ||
| 1058 | 1302 | ||
| 1059 | current = this_CDInterpretation_2; | ||
| 1060 | afterParserOrEnumRuleCall(); | ||
| 1061 | |||
| 1062 | 1303 | ||
| 1063 | } | 1304 | } |
| 1064 | break; | 1305 | |
| 1065 | 1306 | ||
| 1066 | } | 1307 | } |
| 1067 | 1308 | ||
| @@ -1081,28 +1322,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1081 | } | 1322 | } |
| 1082 | return current; | 1323 | return current; |
| 1083 | } | 1324 | } |
| 1084 | // $ANTLR end "ruleInterpretation" | 1325 | // $ANTLR end "ruleUnnamedErrorPrediateDefinition" |
| 1085 | 1326 | ||
| 1086 | 1327 | ||
| 1087 | // $ANTLR start "entryRuleBasicInterpretation" | 1328 | // $ANTLR start "entryRuleDefaultDefinition" |
| 1088 | // InternalSolverLanguage.g:379:1: entryRuleBasicInterpretation returns [EObject current=null] : iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ; | 1329 | // InternalSolverLanguageParser.g:526:1: entryRuleDefaultDefinition returns [EObject current=null] : iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ; |
| 1089 | public final EObject entryRuleBasicInterpretation() throws RecognitionException { | 1330 | public final EObject entryRuleDefaultDefinition() throws RecognitionException { |
| 1090 | EObject current = null; | 1331 | EObject current = null; |
| 1091 | 1332 | ||
| 1092 | EObject iv_ruleBasicInterpretation = null; | 1333 | EObject iv_ruleDefaultDefinition = null; |
| 1093 | 1334 | ||
| 1094 | 1335 | ||
| 1095 | try { | 1336 | try { |
| 1096 | // InternalSolverLanguage.g:379:60: (iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ) | 1337 | // InternalSolverLanguageParser.g:526:58: (iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ) |
| 1097 | // InternalSolverLanguage.g:380:2: iv_ruleBasicInterpretation= ruleBasicInterpretation EOF | 1338 | // InternalSolverLanguageParser.g:527:2: iv_ruleDefaultDefinition= ruleDefaultDefinition EOF |
| 1098 | { | 1339 | { |
| 1099 | newCompositeNode(grammarAccess.getBasicInterpretationRule()); | 1340 | newCompositeNode(grammarAccess.getDefaultDefinitionRule()); |
| 1100 | pushFollow(FOLLOW_1); | 1341 | pushFollow(FOLLOW_1); |
| 1101 | iv_ruleBasicInterpretation=ruleBasicInterpretation(); | 1342 | iv_ruleDefaultDefinition=ruleDefaultDefinition(); |
| 1102 | 1343 | ||
| 1103 | state._fsp--; | 1344 | state._fsp--; |
| 1104 | 1345 | ||
| 1105 | current =iv_ruleBasicInterpretation; | 1346 | current =iv_ruleDefaultDefinition; |
| 1106 | match(input,EOF,FOLLOW_2); | 1347 | match(input,EOF,FOLLOW_2); |
| 1107 | 1348 | ||
| 1108 | } | 1349 | } |
| @@ -1117,60 +1358,58 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1117 | } | 1358 | } |
| 1118 | return current; | 1359 | return current; |
| 1119 | } | 1360 | } |
| 1120 | // $ANTLR end "entryRuleBasicInterpretation" | 1361 | // $ANTLR end "entryRuleDefaultDefinition" |
| 1121 | 1362 | ||
| 1122 | 1363 | ||
| 1123 | // $ANTLR start "ruleBasicInterpretation" | 1364 | // $ANTLR start "ruleDefaultDefinition" |
| 1124 | // InternalSolverLanguage.g:386:1: ruleBasicInterpretation returns [EObject current=null] : ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) ; | 1365 | // InternalSolverLanguageParser.g:533:1: ruleDefaultDefinition returns [EObject current=null] : (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) ; |
| 1125 | public final EObject ruleBasicInterpretation() throws RecognitionException { | 1366 | public final EObject ruleDefaultDefinition() throws RecognitionException { |
| 1126 | EObject current = null; | 1367 | EObject current = null; |
| 1127 | 1368 | ||
| 1128 | Token otherlv_1=null; | 1369 | Token otherlv_0=null; |
| 1129 | Token otherlv_3=null; | 1370 | Token otherlv_2=null; |
| 1130 | Token otherlv_5=null; | 1371 | EObject lv_head_1_0 = null; |
| 1131 | Token otherlv_6=null; | ||
| 1132 | EObject lv_symbol_0_0 = null; | ||
| 1133 | |||
| 1134 | EObject lv_objects_2_0 = null; | ||
| 1135 | |||
| 1136 | EObject lv_objects_4_0 = null; | ||
| 1137 | 1372 | ||
| 1138 | EObject lv_value_7_0 = null; | 1373 | EObject lv_range_3_0 = null; |
| 1139 | 1374 | ||
| 1140 | 1375 | ||
| 1141 | 1376 | ||
| 1142 | enterRule(); | 1377 | enterRule(); |
| 1143 | 1378 | ||
| 1144 | try { | 1379 | try { |
| 1145 | // InternalSolverLanguage.g:392:2: ( ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) ) | 1380 | // InternalSolverLanguageParser.g:539:2: ( (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) ) |
| 1146 | // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) | 1381 | // InternalSolverLanguageParser.g:540:2: (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) |
| 1147 | { | 1382 | { |
| 1148 | // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) ) | 1383 | // InternalSolverLanguageParser.g:540:2: (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) |
| 1149 | // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? otherlv_6= ':' ( (lv_value_7_0= ruleTruthValue ) ) | 1384 | // InternalSolverLanguageParser.g:541:3: otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) |
| 1150 | { | 1385 | { |
| 1151 | // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) | 1386 | otherlv_0=(Token)match(input,Default,FOLLOW_8); |
| 1152 | // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) | 1387 | |
| 1388 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | ||
| 1389 | |||
| 1390 | // InternalSolverLanguageParser.g:545:3: ( (lv_head_1_0= ruleCall ) ) | ||
| 1391 | // InternalSolverLanguageParser.g:546:4: (lv_head_1_0= ruleCall ) | ||
| 1153 | { | 1392 | { |
| 1154 | // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) | 1393 | // InternalSolverLanguageParser.g:546:4: (lv_head_1_0= ruleCall ) |
| 1155 | // InternalSolverLanguage.g:396:5: lv_symbol_0_0= ruleSymbol | 1394 | // InternalSolverLanguageParser.g:547:5: lv_head_1_0= ruleCall |
| 1156 | { | 1395 | { |
| 1157 | 1396 | ||
| 1158 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); | 1397 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 1159 | 1398 | ||
| 1160 | pushFollow(FOLLOW_6); | 1399 | pushFollow(FOLLOW_12); |
| 1161 | lv_symbol_0_0=ruleSymbol(); | 1400 | lv_head_1_0=ruleCall(); |
| 1162 | 1401 | ||
| 1163 | state._fsp--; | 1402 | state._fsp--; |
| 1164 | 1403 | ||
| 1165 | 1404 | ||
| 1166 | if (current==null) { | 1405 | if (current==null) { |
| 1167 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1406 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); |
| 1168 | } | 1407 | } |
| 1169 | set( | 1408 | set( |
| 1170 | current, | 1409 | current, |
| 1171 | "symbol", | 1410 | "head", |
| 1172 | lv_symbol_0_0, | 1411 | lv_head_1_0, |
| 1173 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 1412 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
| 1174 | afterParserOrEnumRuleCall(); | 1413 | afterParserOrEnumRuleCall(); |
| 1175 | 1414 | ||
| 1176 | 1415 | ||
| @@ -1179,165 +1418,145 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1179 | 1418 | ||
| 1180 | } | 1419 | } |
| 1181 | 1420 | ||
| 1182 | // InternalSolverLanguage.g:413:3: (otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' )? | 1421 | otherlv_2=(Token)match(input,Colon,FOLLOW_6); |
| 1183 | int alt10=2; | ||
| 1184 | int LA10_0 = input.LA(1); | ||
| 1185 | 1422 | ||
| 1186 | if ( (LA10_0==17) ) { | 1423 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
| 1187 | alt10=1; | 1424 | |
| 1188 | } | 1425 | // InternalSolverLanguageParser.g:568:3: ( (lv_range_3_0= ruleExpression ) ) |
| 1189 | switch (alt10) { | 1426 | // InternalSolverLanguageParser.g:569:4: (lv_range_3_0= ruleExpression ) |
| 1190 | case 1 : | 1427 | { |
| 1191 | // InternalSolverLanguage.g:414:4: otherlv_1= '(' ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? otherlv_5= ')' | 1428 | // InternalSolverLanguageParser.g:569:4: (lv_range_3_0= ruleExpression ) |
| 1192 | { | 1429 | // InternalSolverLanguageParser.g:570:5: lv_range_3_0= ruleExpression |
| 1193 | otherlv_1=(Token)match(input,17,FOLLOW_7); | 1430 | { |
| 1194 | 1431 | ||
| 1195 | newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); | 1432 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
| 1196 | 1433 | ||
| 1197 | // InternalSolverLanguage.g:418:4: ( ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* )? | 1434 | pushFollow(FOLLOW_2); |
| 1198 | int alt9=2; | 1435 | lv_range_3_0=ruleExpression(); |
| 1199 | int LA9_0 = input.LA(1); | ||
| 1200 | 1436 | ||
| 1201 | if ( ((LA9_0>=RULE_INT && LA9_0<=RULE_STRING)||LA9_0==11||(LA9_0>=13 && LA9_0<=14)||LA9_0==20||LA9_0==27||LA9_0==31) ) { | 1437 | state._fsp--; |
| 1202 | alt9=1; | ||
| 1203 | } | ||
| 1204 | switch (alt9) { | ||
| 1205 | case 1 : | ||
| 1206 | // InternalSolverLanguage.g:419:5: ( (lv_objects_2_0= ruleComplexObject ) ) (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* | ||
| 1207 | { | ||
| 1208 | // InternalSolverLanguage.g:419:5: ( (lv_objects_2_0= ruleComplexObject ) ) | ||
| 1209 | // InternalSolverLanguage.g:420:6: (lv_objects_2_0= ruleComplexObject ) | ||
| 1210 | { | ||
| 1211 | // InternalSolverLanguage.g:420:6: (lv_objects_2_0= ruleComplexObject ) | ||
| 1212 | // InternalSolverLanguage.g:421:7: lv_objects_2_0= ruleComplexObject | ||
| 1213 | { | ||
| 1214 | 1438 | ||
| 1215 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); | ||
| 1216 | |||
| 1217 | pushFollow(FOLLOW_8); | ||
| 1218 | lv_objects_2_0=ruleComplexObject(); | ||
| 1219 | 1439 | ||
| 1220 | state._fsp--; | 1440 | if (current==null) { |
| 1441 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | ||
| 1442 | } | ||
| 1443 | set( | ||
| 1444 | current, | ||
| 1445 | "range", | ||
| 1446 | lv_range_3_0, | ||
| 1447 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1448 | afterParserOrEnumRuleCall(); | ||
| 1449 | |||
| 1221 | 1450 | ||
| 1451 | } | ||
| 1222 | 1452 | ||
| 1223 | if (current==null) { | ||
| 1224 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 1225 | } | ||
| 1226 | add( | ||
| 1227 | current, | ||
| 1228 | "objects", | ||
| 1229 | lv_objects_2_0, | ||
| 1230 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 1231 | afterParserOrEnumRuleCall(); | ||
| 1232 | |||
| 1233 | 1453 | ||
| 1234 | } | 1454 | } |
| 1235 | 1455 | ||
| 1236 | 1456 | ||
| 1237 | } | 1457 | } |
| 1238 | 1458 | ||
| 1239 | // InternalSolverLanguage.g:438:5: (otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) )* | ||
| 1240 | loop8: | ||
| 1241 | do { | ||
| 1242 | int alt8=2; | ||
| 1243 | int LA8_0 = input.LA(1); | ||
| 1244 | 1459 | ||
| 1245 | if ( (LA8_0==18) ) { | 1460 | } |
| 1246 | alt8=1; | ||
| 1247 | } | ||
| 1248 | 1461 | ||
| 1249 | 1462 | ||
| 1250 | switch (alt8) { | 1463 | leaveRule(); |
| 1251 | case 1 : | ||
| 1252 | // InternalSolverLanguage.g:439:6: otherlv_3= ',' ( (lv_objects_4_0= ruleComplexObject ) ) | ||
| 1253 | { | ||
| 1254 | otherlv_3=(Token)match(input,18,FOLLOW_9); | ||
| 1255 | 1464 | ||
| 1256 | newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); | 1465 | } |
| 1257 | |||
| 1258 | // InternalSolverLanguage.g:443:6: ( (lv_objects_4_0= ruleComplexObject ) ) | ||
| 1259 | // InternalSolverLanguage.g:444:7: (lv_objects_4_0= ruleComplexObject ) | ||
| 1260 | { | ||
| 1261 | // InternalSolverLanguage.g:444:7: (lv_objects_4_0= ruleComplexObject ) | ||
| 1262 | // InternalSolverLanguage.g:445:8: lv_objects_4_0= ruleComplexObject | ||
| 1263 | { | ||
| 1264 | 1466 | ||
| 1265 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); | 1467 | catch (RecognitionException re) { |
| 1266 | 1468 | recover(input,re); | |
| 1267 | pushFollow(FOLLOW_8); | 1469 | appendSkippedTokens(); |
| 1268 | lv_objects_4_0=ruleComplexObject(); | 1470 | } |
| 1471 | finally { | ||
| 1472 | } | ||
| 1473 | return current; | ||
| 1474 | } | ||
| 1475 | // $ANTLR end "ruleDefaultDefinition" | ||
| 1269 | 1476 | ||
| 1270 | state._fsp--; | ||
| 1271 | 1477 | ||
| 1478 | // $ANTLR start "entryRuleExternPredicateDefinition" | ||
| 1479 | // InternalSolverLanguageParser.g:591:1: entryRuleExternPredicateDefinition returns [EObject current=null] : iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ; | ||
| 1480 | public final EObject entryRuleExternPredicateDefinition() throws RecognitionException { | ||
| 1481 | EObject current = null; | ||
| 1272 | 1482 | ||
| 1273 | if (current==null) { | 1483 | EObject iv_ruleExternPredicateDefinition = null; |
| 1274 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | ||
| 1275 | } | ||
| 1276 | add( | ||
| 1277 | current, | ||
| 1278 | "objects", | ||
| 1279 | lv_objects_4_0, | ||
| 1280 | "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | ||
| 1281 | afterParserOrEnumRuleCall(); | ||
| 1282 | |||
| 1283 | 1484 | ||
| 1284 | } | ||
| 1285 | 1485 | ||
| 1486 | try { | ||
| 1487 | // InternalSolverLanguageParser.g:591:66: (iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ) | ||
| 1488 | // InternalSolverLanguageParser.g:592:2: iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF | ||
| 1489 | { | ||
| 1490 | newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); | ||
| 1491 | pushFollow(FOLLOW_1); | ||
| 1492 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition(); | ||
| 1286 | 1493 | ||
| 1287 | } | 1494 | state._fsp--; |
| 1288 | 1495 | ||
| 1496 | current =iv_ruleExternPredicateDefinition; | ||
| 1497 | match(input,EOF,FOLLOW_2); | ||
| 1289 | 1498 | ||
| 1290 | } | 1499 | } |
| 1291 | break; | ||
| 1292 | 1500 | ||
| 1293 | default : | 1501 | } |
| 1294 | break loop8; | ||
| 1295 | } | ||
| 1296 | } while (true); | ||
| 1297 | 1502 | ||
| 1503 | catch (RecognitionException re) { | ||
| 1504 | recover(input,re); | ||
| 1505 | appendSkippedTokens(); | ||
| 1506 | } | ||
| 1507 | finally { | ||
| 1508 | } | ||
| 1509 | return current; | ||
| 1510 | } | ||
| 1511 | // $ANTLR end "entryRuleExternPredicateDefinition" | ||
| 1298 | 1512 | ||
| 1299 | } | ||
| 1300 | break; | ||
| 1301 | 1513 | ||
| 1302 | } | 1514 | // $ANTLR start "ruleExternPredicateDefinition" |
| 1515 | // InternalSolverLanguageParser.g:598:1: ruleExternPredicateDefinition returns [EObject current=null] : (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) ; | ||
| 1516 | public final EObject ruleExternPredicateDefinition() throws RecognitionException { | ||
| 1517 | EObject current = null; | ||
| 1303 | 1518 | ||
| 1304 | otherlv_5=(Token)match(input,19,FOLLOW_10); | 1519 | Token otherlv_0=null; |
| 1520 | EObject lv_head_1_0 = null; | ||
| 1305 | 1521 | ||
| 1306 | newLeafNode(otherlv_5, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); | ||
| 1307 | |||
| 1308 | 1522 | ||
| 1309 | } | ||
| 1310 | break; | ||
| 1311 | 1523 | ||
| 1312 | } | 1524 | enterRule(); |
| 1313 | 1525 | ||
| 1314 | otherlv_6=(Token)match(input,20,FOLLOW_11); | 1526 | try { |
| 1527 | // InternalSolverLanguageParser.g:604:2: ( (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) ) | ||
| 1528 | // InternalSolverLanguageParser.g:605:2: (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) | ||
| 1529 | { | ||
| 1530 | // InternalSolverLanguageParser.g:605:2: (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) | ||
| 1531 | // InternalSolverLanguageParser.g:606:3: otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) | ||
| 1532 | { | ||
| 1533 | otherlv_0=(Token)match(input,Extern,FOLLOW_8); | ||
| 1315 | 1534 | ||
| 1316 | newLeafNode(otherlv_6, grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); | 1535 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); |
| 1317 | 1536 | ||
| 1318 | // InternalSolverLanguage.g:473:3: ( (lv_value_7_0= ruleTruthValue ) ) | 1537 | // InternalSolverLanguageParser.g:610:3: ( (lv_head_1_0= ruleCall ) ) |
| 1319 | // InternalSolverLanguage.g:474:4: (lv_value_7_0= ruleTruthValue ) | 1538 | // InternalSolverLanguageParser.g:611:4: (lv_head_1_0= ruleCall ) |
| 1320 | { | 1539 | { |
| 1321 | // InternalSolverLanguage.g:474:4: (lv_value_7_0= ruleTruthValue ) | 1540 | // InternalSolverLanguageParser.g:611:4: (lv_head_1_0= ruleCall ) |
| 1322 | // InternalSolverLanguage.g:475:5: lv_value_7_0= ruleTruthValue | 1541 | // InternalSolverLanguageParser.g:612:5: lv_head_1_0= ruleCall |
| 1323 | { | 1542 | { |
| 1324 | 1543 | ||
| 1325 | newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); | 1544 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
| 1326 | 1545 | ||
| 1327 | pushFollow(FOLLOW_2); | 1546 | pushFollow(FOLLOW_2); |
| 1328 | lv_value_7_0=ruleTruthValue(); | 1547 | lv_head_1_0=ruleCall(); |
| 1329 | 1548 | ||
| 1330 | state._fsp--; | 1549 | state._fsp--; |
| 1331 | 1550 | ||
| 1332 | 1551 | ||
| 1333 | if (current==null) { | 1552 | if (current==null) { |
| 1334 | current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); | 1553 | current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); |
| 1335 | } | 1554 | } |
| 1336 | set( | 1555 | set( |
| 1337 | current, | 1556 | current, |
| 1338 | "value", | 1557 | "head", |
| 1339 | lv_value_7_0, | 1558 | lv_head_1_0, |
| 1340 | "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | 1559 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
| 1341 | afterParserOrEnumRuleCall(); | 1560 | afterParserOrEnumRuleCall(); |
| 1342 | 1561 | ||
| 1343 | 1562 | ||
| @@ -1365,28 +1584,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1365 | } | 1584 | } |
| 1366 | return current; | 1585 | return current; |
| 1367 | } | 1586 | } |
| 1368 | // $ANTLR end "ruleBasicInterpretation" | 1587 | // $ANTLR end "ruleExternPredicateDefinition" |
| 1369 | 1588 | ||
| 1370 | 1589 | ||
| 1371 | // $ANTLR start "entryRuleSymbol" | 1590 | // $ANTLR start "entryRuleMetricDefinition" |
| 1372 | // InternalSolverLanguage.g:496:1: entryRuleSymbol returns [EObject current=null] : iv_ruleSymbol= ruleSymbol EOF ; | 1591 | // InternalSolverLanguageParser.g:633:1: entryRuleMetricDefinition returns [EObject current=null] : iv_ruleMetricDefinition= ruleMetricDefinition EOF ; |
| 1373 | public final EObject entryRuleSymbol() throws RecognitionException { | 1592 | public final EObject entryRuleMetricDefinition() throws RecognitionException { |
| 1374 | EObject current = null; | 1593 | EObject current = null; |
| 1375 | 1594 | ||
| 1376 | EObject iv_ruleSymbol = null; | 1595 | EObject iv_ruleMetricDefinition = null; |
| 1377 | 1596 | ||
| 1378 | 1597 | ||
| 1379 | try { | 1598 | try { |
| 1380 | // InternalSolverLanguage.g:496:47: (iv_ruleSymbol= ruleSymbol EOF ) | 1599 | // InternalSolverLanguageParser.g:633:57: (iv_ruleMetricDefinition= ruleMetricDefinition EOF ) |
| 1381 | // InternalSolverLanguage.g:497:2: iv_ruleSymbol= ruleSymbol EOF | 1600 | // InternalSolverLanguageParser.g:634:2: iv_ruleMetricDefinition= ruleMetricDefinition EOF |
| 1382 | { | 1601 | { |
| 1383 | newCompositeNode(grammarAccess.getSymbolRule()); | 1602 | newCompositeNode(grammarAccess.getMetricDefinitionRule()); |
| 1384 | pushFollow(FOLLOW_1); | 1603 | pushFollow(FOLLOW_1); |
| 1385 | iv_ruleSymbol=ruleSymbol(); | 1604 | iv_ruleMetricDefinition=ruleMetricDefinition(); |
| 1386 | 1605 | ||
| 1387 | state._fsp--; | 1606 | state._fsp--; |
| 1388 | 1607 | ||
| 1389 | current =iv_ruleSymbol; | 1608 | current =iv_ruleMetricDefinition; |
| 1390 | match(input,EOF,FOLLOW_2); | 1609 | match(input,EOF,FOLLOW_2); |
| 1391 | 1610 | ||
| 1392 | } | 1611 | } |
| @@ -1401,112 +1620,129 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1401 | } | 1620 | } |
| 1402 | return current; | 1621 | return current; |
| 1403 | } | 1622 | } |
| 1404 | // $ANTLR end "entryRuleSymbol" | 1623 | // $ANTLR end "entryRuleMetricDefinition" |
| 1405 | 1624 | ||
| 1406 | 1625 | ||
| 1407 | // $ANTLR start "ruleSymbol" | 1626 | // $ANTLR start "ruleMetricDefinition" |
| 1408 | // InternalSolverLanguage.g:503:1: ruleSymbol returns [EObject current=null] : (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ; | 1627 | // InternalSolverLanguageParser.g:640:1: ruleMetricDefinition returns [EObject current=null] : ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) ; |
| 1409 | public final EObject ruleSymbol() throws RecognitionException { | 1628 | public final EObject ruleMetricDefinition() throws RecognitionException { |
| 1410 | EObject current = null; | 1629 | EObject current = null; |
| 1411 | 1630 | ||
| 1412 | EObject this_ModelSymbol_0 = null; | 1631 | Token otherlv_2=null; |
| 1632 | Enumerator lv_type_0_0 = null; | ||
| 1413 | 1633 | ||
| 1414 | EObject this_PartialitySymbol_1 = null; | 1634 | EObject lv_head_1_0 = null; |
| 1415 | 1635 | ||
| 1416 | EObject this_DataSymbol_2 = null; | 1636 | EObject lv_body_3_0 = null; |
| 1417 | 1637 | ||
| 1418 | 1638 | ||
| 1419 | 1639 | ||
| 1420 | enterRule(); | 1640 | enterRule(); |
| 1421 | 1641 | ||
| 1422 | try { | 1642 | try { |
| 1423 | // InternalSolverLanguage.g:509:2: ( (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ) | 1643 | // InternalSolverLanguageParser.g:646:2: ( ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) ) |
| 1424 | // InternalSolverLanguage.g:510:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) | 1644 | // InternalSolverLanguageParser.g:647:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) |
| 1645 | { | ||
| 1646 | // InternalSolverLanguageParser.g:647:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) | ||
| 1647 | // InternalSolverLanguageParser.g:648:3: ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) | ||
| 1648 | { | ||
| 1649 | // InternalSolverLanguageParser.g:648:3: ( (lv_type_0_0= ruleMetricType ) ) | ||
| 1650 | // InternalSolverLanguageParser.g:649:4: (lv_type_0_0= ruleMetricType ) | ||
| 1651 | { | ||
| 1652 | // InternalSolverLanguageParser.g:649:4: (lv_type_0_0= ruleMetricType ) | ||
| 1653 | // InternalSolverLanguageParser.g:650:5: lv_type_0_0= ruleMetricType | ||
| 1425 | { | 1654 | { |
| 1426 | // InternalSolverLanguage.g:510:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) | ||
| 1427 | int alt11=3; | ||
| 1428 | switch ( input.LA(1) ) { | ||
| 1429 | case RULE_ID: | ||
| 1430 | { | ||
| 1431 | alt11=1; | ||
| 1432 | } | ||
| 1433 | break; | ||
| 1434 | case 21: | ||
| 1435 | case 22: | ||
| 1436 | { | ||
| 1437 | alt11=2; | ||
| 1438 | } | ||
| 1439 | break; | ||
| 1440 | case 23: | ||
| 1441 | case 24: | ||
| 1442 | case 25: | ||
| 1443 | case 26: | ||
| 1444 | { | ||
| 1445 | alt11=3; | ||
| 1446 | } | ||
| 1447 | break; | ||
| 1448 | default: | ||
| 1449 | NoViableAltException nvae = | ||
| 1450 | new NoViableAltException("", 11, 0, input); | ||
| 1451 | 1655 | ||
| 1452 | throw nvae; | 1656 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
| 1657 | |||
| 1658 | pushFollow(FOLLOW_6); | ||
| 1659 | lv_type_0_0=ruleMetricType(); | ||
| 1660 | |||
| 1661 | state._fsp--; | ||
| 1662 | |||
| 1663 | |||
| 1664 | if (current==null) { | ||
| 1665 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | ||
| 1666 | } | ||
| 1667 | set( | ||
| 1668 | current, | ||
| 1669 | "type", | ||
| 1670 | lv_type_0_0, | ||
| 1671 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 1672 | afterParserOrEnumRuleCall(); | ||
| 1673 | |||
| 1674 | |||
| 1453 | } | 1675 | } |
| 1454 | 1676 | ||
| 1455 | switch (alt11) { | ||
| 1456 | case 1 : | ||
| 1457 | // InternalSolverLanguage.g:511:3: this_ModelSymbol_0= ruleModelSymbol | ||
| 1458 | { | ||
| 1459 | 1677 | ||
| 1460 | newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); | 1678 | } |
| 1461 | |||
| 1462 | pushFollow(FOLLOW_2); | ||
| 1463 | this_ModelSymbol_0=ruleModelSymbol(); | ||
| 1464 | 1679 | ||
| 1465 | state._fsp--; | 1680 | // InternalSolverLanguageParser.g:667:3: ( (lv_head_1_0= ruleExpression ) ) |
| 1681 | // InternalSolverLanguageParser.g:668:4: (lv_head_1_0= ruleExpression ) | ||
| 1682 | { | ||
| 1683 | // InternalSolverLanguageParser.g:668:4: (lv_head_1_0= ruleExpression ) | ||
| 1684 | // InternalSolverLanguageParser.g:669:5: lv_head_1_0= ruleExpression | ||
| 1685 | { | ||
| 1466 | 1686 | ||
| 1687 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); | ||
| 1688 | |||
| 1689 | pushFollow(FOLLOW_13); | ||
| 1690 | lv_head_1_0=ruleExpression(); | ||
| 1467 | 1691 | ||
| 1468 | current = this_ModelSymbol_0; | 1692 | state._fsp--; |
| 1469 | afterParserOrEnumRuleCall(); | ||
| 1470 | |||
| 1471 | 1693 | ||
| 1472 | } | ||
| 1473 | break; | ||
| 1474 | case 2 : | ||
| 1475 | // InternalSolverLanguage.g:520:3: this_PartialitySymbol_1= rulePartialitySymbol | ||
| 1476 | { | ||
| 1477 | 1694 | ||
| 1478 | newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); | 1695 | if (current==null) { |
| 1479 | 1696 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | |
| 1480 | pushFollow(FOLLOW_2); | 1697 | } |
| 1481 | this_PartialitySymbol_1=rulePartialitySymbol(); | 1698 | set( |
| 1699 | current, | ||
| 1700 | "head", | ||
| 1701 | lv_head_1_0, | ||
| 1702 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1703 | afterParserOrEnumRuleCall(); | ||
| 1704 | |||
| 1482 | 1705 | ||
| 1483 | state._fsp--; | 1706 | } |
| 1484 | 1707 | ||
| 1485 | 1708 | ||
| 1486 | current = this_PartialitySymbol_1; | 1709 | } |
| 1487 | afterParserOrEnumRuleCall(); | ||
| 1488 | |||
| 1489 | 1710 | ||
| 1490 | } | 1711 | otherlv_2=(Token)match(input,EqualsSign,FOLLOW_6); |
| 1491 | break; | ||
| 1492 | case 3 : | ||
| 1493 | // InternalSolverLanguage.g:529:3: this_DataSymbol_2= ruleDataSymbol | ||
| 1494 | { | ||
| 1495 | 1712 | ||
| 1496 | newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); | 1713 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); |
| 1497 | 1714 | ||
| 1498 | pushFollow(FOLLOW_2); | 1715 | // InternalSolverLanguageParser.g:690:3: ( (lv_body_3_0= ruleExpression ) ) |
| 1499 | this_DataSymbol_2=ruleDataSymbol(); | 1716 | // InternalSolverLanguageParser.g:691:4: (lv_body_3_0= ruleExpression ) |
| 1717 | { | ||
| 1718 | // InternalSolverLanguageParser.g:691:4: (lv_body_3_0= ruleExpression ) | ||
| 1719 | // InternalSolverLanguageParser.g:692:5: lv_body_3_0= ruleExpression | ||
| 1720 | { | ||
| 1500 | 1721 | ||
| 1501 | state._fsp--; | 1722 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
| 1723 | |||
| 1724 | pushFollow(FOLLOW_2); | ||
| 1725 | lv_body_3_0=ruleExpression(); | ||
| 1502 | 1726 | ||
| 1727 | state._fsp--; | ||
| 1503 | 1728 | ||
| 1504 | current = this_DataSymbol_2; | ||
| 1505 | afterParserOrEnumRuleCall(); | ||
| 1506 | |||
| 1507 | 1729 | ||
| 1508 | } | 1730 | if (current==null) { |
| 1509 | break; | 1731 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); |
| 1732 | } | ||
| 1733 | set( | ||
| 1734 | current, | ||
| 1735 | "body", | ||
| 1736 | lv_body_3_0, | ||
| 1737 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 1738 | afterParserOrEnumRuleCall(); | ||
| 1739 | |||
| 1740 | |||
| 1741 | } | ||
| 1742 | |||
| 1743 | |||
| 1744 | } | ||
| 1745 | |||
| 1510 | 1746 | ||
| 1511 | } | 1747 | } |
| 1512 | 1748 | ||
| @@ -1526,28 +1762,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1526 | } | 1762 | } |
| 1527 | return current; | 1763 | return current; |
| 1528 | } | 1764 | } |
| 1529 | // $ANTLR end "ruleSymbol" | 1765 | // $ANTLR end "ruleMetricDefinition" |
| 1530 | 1766 | ||
| 1531 | 1767 | ||
| 1532 | // $ANTLR start "entryRuleModelSymbol" | 1768 | // $ANTLR start "entryRuleExternMetricDefinition" |
| 1533 | // InternalSolverLanguage.g:541:1: entryRuleModelSymbol returns [EObject current=null] : iv_ruleModelSymbol= ruleModelSymbol EOF ; | 1769 | // InternalSolverLanguageParser.g:713:1: entryRuleExternMetricDefinition returns [EObject current=null] : iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ; |
| 1534 | public final EObject entryRuleModelSymbol() throws RecognitionException { | 1770 | public final EObject entryRuleExternMetricDefinition() throws RecognitionException { |
| 1535 | EObject current = null; | 1771 | EObject current = null; |
| 1536 | 1772 | ||
| 1537 | EObject iv_ruleModelSymbol = null; | 1773 | EObject iv_ruleExternMetricDefinition = null; |
| 1538 | 1774 | ||
| 1539 | 1775 | ||
| 1540 | try { | 1776 | try { |
| 1541 | // InternalSolverLanguage.g:541:52: (iv_ruleModelSymbol= ruleModelSymbol EOF ) | 1777 | // InternalSolverLanguageParser.g:713:63: (iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ) |
| 1542 | // InternalSolverLanguage.g:542:2: iv_ruleModelSymbol= ruleModelSymbol EOF | 1778 | // InternalSolverLanguageParser.g:714:2: iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF |
| 1543 | { | 1779 | { |
| 1544 | newCompositeNode(grammarAccess.getModelSymbolRule()); | 1780 | newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); |
| 1545 | pushFollow(FOLLOW_1); | 1781 | pushFollow(FOLLOW_1); |
| 1546 | iv_ruleModelSymbol=ruleModelSymbol(); | 1782 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition(); |
| 1547 | 1783 | ||
| 1548 | state._fsp--; | 1784 | state._fsp--; |
| 1549 | 1785 | ||
| 1550 | current =iv_ruleModelSymbol; | 1786 | current =iv_ruleExternMetricDefinition; |
| 1551 | match(input,EOF,FOLLOW_2); | 1787 | match(input,EOF,FOLLOW_2); |
| 1552 | 1788 | ||
| 1553 | } | 1789 | } |
| @@ -1562,43 +1798,93 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1562 | } | 1798 | } |
| 1563 | return current; | 1799 | return current; |
| 1564 | } | 1800 | } |
| 1565 | // $ANTLR end "entryRuleModelSymbol" | 1801 | // $ANTLR end "entryRuleExternMetricDefinition" |
| 1566 | 1802 | ||
| 1567 | 1803 | ||
| 1568 | // $ANTLR start "ruleModelSymbol" | 1804 | // $ANTLR start "ruleExternMetricDefinition" |
| 1569 | // InternalSolverLanguage.g:548:1: ruleModelSymbol returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 1805 | // InternalSolverLanguageParser.g:720:1: ruleExternMetricDefinition returns [EObject current=null] : (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ; |
| 1570 | public final EObject ruleModelSymbol() throws RecognitionException { | 1806 | public final EObject ruleExternMetricDefinition() throws RecognitionException { |
| 1571 | EObject current = null; | 1807 | EObject current = null; |
| 1572 | 1808 | ||
| 1573 | Token lv_name_0_0=null; | 1809 | Token otherlv_0=null; |
| 1810 | Enumerator lv_type_1_0 = null; | ||
| 1811 | |||
| 1812 | EObject lv_head_2_0 = null; | ||
| 1813 | |||
| 1574 | 1814 | ||
| 1575 | 1815 | ||
| 1576 | enterRule(); | 1816 | enterRule(); |
| 1577 | 1817 | ||
| 1578 | try { | 1818 | try { |
| 1579 | // InternalSolverLanguage.g:554:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 1819 | // InternalSolverLanguageParser.g:726:2: ( (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ) |
| 1580 | // InternalSolverLanguage.g:555:2: ( (lv_name_0_0= RULE_ID ) ) | 1820 | // InternalSolverLanguageParser.g:727:2: (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) |
| 1821 | { | ||
| 1822 | // InternalSolverLanguageParser.g:727:2: (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) | ||
| 1823 | // InternalSolverLanguageParser.g:728:3: otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) | ||
| 1581 | { | 1824 | { |
| 1582 | // InternalSolverLanguage.g:555:2: ( (lv_name_0_0= RULE_ID ) ) | 1825 | otherlv_0=(Token)match(input,Extern,FOLLOW_14); |
| 1583 | // InternalSolverLanguage.g:556:3: (lv_name_0_0= RULE_ID ) | 1826 | |
| 1827 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | ||
| 1828 | |||
| 1829 | // InternalSolverLanguageParser.g:732:3: ( (lv_type_1_0= ruleMetricType ) ) | ||
| 1830 | // InternalSolverLanguageParser.g:733:4: (lv_type_1_0= ruleMetricType ) | ||
| 1584 | { | 1831 | { |
| 1585 | // InternalSolverLanguage.g:556:3: (lv_name_0_0= RULE_ID ) | 1832 | // InternalSolverLanguageParser.g:733:4: (lv_type_1_0= ruleMetricType ) |
| 1586 | // InternalSolverLanguage.g:557:4: lv_name_0_0= RULE_ID | 1833 | // InternalSolverLanguageParser.g:734:5: lv_type_1_0= ruleMetricType |
| 1587 | { | 1834 | { |
| 1588 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
| 1589 | 1835 | ||
| 1590 | newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); | 1836 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); |
| 1591 | 1837 | ||
| 1838 | pushFollow(FOLLOW_8); | ||
| 1839 | lv_type_1_0=ruleMetricType(); | ||
| 1840 | |||
| 1841 | state._fsp--; | ||
| 1842 | |||
| 1843 | |||
| 1844 | if (current==null) { | ||
| 1845 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 1846 | } | ||
| 1847 | set( | ||
| 1848 | current, | ||
| 1849 | "type", | ||
| 1850 | lv_type_1_0, | ||
| 1851 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 1852 | afterParserOrEnumRuleCall(); | ||
| 1853 | |||
| 1854 | |||
| 1855 | } | ||
| 1856 | |||
| 1857 | |||
| 1858 | } | ||
| 1859 | |||
| 1860 | // InternalSolverLanguageParser.g:751:3: ( (lv_head_2_0= ruleCall ) ) | ||
| 1861 | // InternalSolverLanguageParser.g:752:4: (lv_head_2_0= ruleCall ) | ||
| 1862 | { | ||
| 1863 | // InternalSolverLanguageParser.g:752:4: (lv_head_2_0= ruleCall ) | ||
| 1864 | // InternalSolverLanguageParser.g:753:5: lv_head_2_0= ruleCall | ||
| 1865 | { | ||
| 1866 | |||
| 1867 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
| 1868 | |||
| 1869 | pushFollow(FOLLOW_2); | ||
| 1870 | lv_head_2_0=ruleCall(); | ||
| 1871 | |||
| 1872 | state._fsp--; | ||
| 1873 | |||
| 1874 | |||
| 1875 | if (current==null) { | ||
| 1876 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | ||
| 1877 | } | ||
| 1878 | set( | ||
| 1879 | current, | ||
| 1880 | "head", | ||
| 1881 | lv_head_2_0, | ||
| 1882 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
| 1883 | afterParserOrEnumRuleCall(); | ||
| 1884 | |||
| 1885 | |||
| 1886 | } | ||
| 1592 | 1887 | ||
| 1593 | if (current==null) { | ||
| 1594 | current = createModelElement(grammarAccess.getModelSymbolRule()); | ||
| 1595 | } | ||
| 1596 | setWithLastConsumed( | ||
| 1597 | current, | ||
| 1598 | "name", | ||
| 1599 | lv_name_0_0, | ||
| 1600 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 1601 | |||
| 1602 | 1888 | ||
| 1603 | } | 1889 | } |
| 1604 | 1890 | ||
| @@ -1621,28 +1907,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1621 | } | 1907 | } |
| 1622 | return current; | 1908 | return current; |
| 1623 | } | 1909 | } |
| 1624 | // $ANTLR end "ruleModelSymbol" | 1910 | // $ANTLR end "ruleExternMetricDefinition" |
| 1625 | 1911 | ||
| 1626 | 1912 | ||
| 1627 | // $ANTLR start "entryRulePartialitySymbol" | 1913 | // $ANTLR start "entryRuleExpression" |
| 1628 | // InternalSolverLanguage.g:576:1: entryRulePartialitySymbol returns [EObject current=null] : iv_rulePartialitySymbol= rulePartialitySymbol EOF ; | 1914 | // InternalSolverLanguageParser.g:774:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ; |
| 1629 | public final EObject entryRulePartialitySymbol() throws RecognitionException { | 1915 | public final EObject entryRuleExpression() throws RecognitionException { |
| 1630 | EObject current = null; | 1916 | EObject current = null; |
| 1631 | 1917 | ||
| 1632 | EObject iv_rulePartialitySymbol = null; | 1918 | EObject iv_ruleExpression = null; |
| 1633 | 1919 | ||
| 1634 | 1920 | ||
| 1635 | try { | 1921 | try { |
| 1636 | // InternalSolverLanguage.g:576:57: (iv_rulePartialitySymbol= rulePartialitySymbol EOF ) | 1922 | // InternalSolverLanguageParser.g:774:51: (iv_ruleExpression= ruleExpression EOF ) |
| 1637 | // InternalSolverLanguage.g:577:2: iv_rulePartialitySymbol= rulePartialitySymbol EOF | 1923 | // InternalSolverLanguageParser.g:775:2: iv_ruleExpression= ruleExpression EOF |
| 1638 | { | 1924 | { |
| 1639 | newCompositeNode(grammarAccess.getPartialitySymbolRule()); | 1925 | newCompositeNode(grammarAccess.getExpressionRule()); |
| 1640 | pushFollow(FOLLOW_1); | 1926 | pushFollow(FOLLOW_1); |
| 1641 | iv_rulePartialitySymbol=rulePartialitySymbol(); | 1927 | iv_ruleExpression=ruleExpression(); |
| 1642 | 1928 | ||
| 1643 | state._fsp--; | 1929 | state._fsp--; |
| 1644 | 1930 | ||
| 1645 | current =iv_rulePartialitySymbol; | 1931 | current =iv_ruleExpression; |
| 1646 | match(input,EOF,FOLLOW_2); | 1932 | match(input,EOF,FOLLOW_2); |
| 1647 | 1933 | ||
| 1648 | } | 1934 | } |
| @@ -1657,74 +1943,74 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1657 | } | 1943 | } |
| 1658 | return current; | 1944 | return current; |
| 1659 | } | 1945 | } |
| 1660 | // $ANTLR end "entryRulePartialitySymbol" | 1946 | // $ANTLR end "entryRuleExpression" |
| 1661 | 1947 | ||
| 1662 | 1948 | ||
| 1663 | // $ANTLR start "rulePartialitySymbol" | 1949 | // $ANTLR start "ruleExpression" |
| 1664 | // InternalSolverLanguage.g:583:1: rulePartialitySymbol returns [EObject current=null] : (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ; | 1950 | // InternalSolverLanguageParser.g:781:1: ruleExpression returns [EObject current=null] : (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ; |
| 1665 | public final EObject rulePartialitySymbol() throws RecognitionException { | 1951 | public final EObject ruleExpression() throws RecognitionException { |
| 1666 | EObject current = null; | 1952 | EObject current = null; |
| 1667 | 1953 | ||
| 1668 | EObject this_ExistSymbol_0 = null; | 1954 | EObject this_IfElse_0 = null; |
| 1669 | 1955 | ||
| 1670 | EObject this_EqualsSymbol_1 = null; | 1956 | EObject this_DisjunctiveExpression_1 = null; |
| 1671 | 1957 | ||
| 1672 | 1958 | ||
| 1673 | 1959 | ||
| 1674 | enterRule(); | 1960 | enterRule(); |
| 1675 | 1961 | ||
| 1676 | try { | 1962 | try { |
| 1677 | // InternalSolverLanguage.g:589:2: ( (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ) | 1963 | // InternalSolverLanguageParser.g:787:2: ( (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ) |
| 1678 | // InternalSolverLanguage.g:590:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) | 1964 | // InternalSolverLanguageParser.g:788:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
| 1679 | { | 1965 | { |
| 1680 | // InternalSolverLanguage.g:590:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) | 1966 | // InternalSolverLanguageParser.g:788:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
| 1681 | int alt12=2; | 1967 | int alt8=2; |
| 1682 | int LA12_0 = input.LA(1); | 1968 | int LA8_0 = input.LA(1); |
| 1683 | 1969 | ||
| 1684 | if ( (LA12_0==21) ) { | 1970 | if ( (LA8_0==If) ) { |
| 1685 | alt12=1; | 1971 | alt8=1; |
| 1686 | } | 1972 | } |
| 1687 | else if ( (LA12_0==22) ) { | 1973 | else if ( (LA8_0==Current||LA8_0==Unknown||(LA8_0>=Count && LA8_0<=False)||(LA8_0>=Must && LA8_0<=Prod)||LA8_0==True||(LA8_0>=Avg && LA8_0<=Inf)||(LA8_0>=Max && LA8_0<=Sum)||(LA8_0>=ExclamationMark && LA8_0<=LeftParenthesis)||LA8_0==PlusSign||LA8_0==HyphenMinus||LA8_0==LeftSquareBracket||(LA8_0>=RULE_STRING && LA8_0<=RULE_QUOTED_ID)||(LA8_0>=RULE_ID && LA8_0<=RULE_INT)) ) { |
| 1688 | alt12=2; | 1974 | alt8=2; |
| 1689 | } | 1975 | } |
| 1690 | else { | 1976 | else { |
| 1691 | NoViableAltException nvae = | 1977 | NoViableAltException nvae = |
| 1692 | new NoViableAltException("", 12, 0, input); | 1978 | new NoViableAltException("", 8, 0, input); |
| 1693 | 1979 | ||
| 1694 | throw nvae; | 1980 | throw nvae; |
| 1695 | } | 1981 | } |
| 1696 | switch (alt12) { | 1982 | switch (alt8) { |
| 1697 | case 1 : | 1983 | case 1 : |
| 1698 | // InternalSolverLanguage.g:591:3: this_ExistSymbol_0= ruleExistSymbol | 1984 | // InternalSolverLanguageParser.g:789:3: this_IfElse_0= ruleIfElse |
| 1699 | { | 1985 | { |
| 1700 | 1986 | ||
| 1701 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); | 1987 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
| 1702 | 1988 | ||
| 1703 | pushFollow(FOLLOW_2); | 1989 | pushFollow(FOLLOW_2); |
| 1704 | this_ExistSymbol_0=ruleExistSymbol(); | 1990 | this_IfElse_0=ruleIfElse(); |
| 1705 | 1991 | ||
| 1706 | state._fsp--; | 1992 | state._fsp--; |
| 1707 | 1993 | ||
| 1708 | 1994 | ||
| 1709 | current = this_ExistSymbol_0; | 1995 | current = this_IfElse_0; |
| 1710 | afterParserOrEnumRuleCall(); | 1996 | afterParserOrEnumRuleCall(); |
| 1711 | 1997 | ||
| 1712 | 1998 | ||
| 1713 | } | 1999 | } |
| 1714 | break; | 2000 | break; |
| 1715 | case 2 : | 2001 | case 2 : |
| 1716 | // InternalSolverLanguage.g:600:3: this_EqualsSymbol_1= ruleEqualsSymbol | 2002 | // InternalSolverLanguageParser.g:798:3: this_DisjunctiveExpression_1= ruleDisjunctiveExpression |
| 1717 | { | 2003 | { |
| 1718 | 2004 | ||
| 1719 | newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); | 2005 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
| 1720 | 2006 | ||
| 1721 | pushFollow(FOLLOW_2); | 2007 | pushFollow(FOLLOW_2); |
| 1722 | this_EqualsSymbol_1=ruleEqualsSymbol(); | 2008 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression(); |
| 1723 | 2009 | ||
| 1724 | state._fsp--; | 2010 | state._fsp--; |
| 1725 | 2011 | ||
| 1726 | 2012 | ||
| 1727 | current = this_EqualsSymbol_1; | 2013 | current = this_DisjunctiveExpression_1; |
| 1728 | afterParserOrEnumRuleCall(); | 2014 | afterParserOrEnumRuleCall(); |
| 1729 | 2015 | ||
| 1730 | 2016 | ||
| @@ -1749,28 +2035,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1749 | } | 2035 | } |
| 1750 | return current; | 2036 | return current; |
| 1751 | } | 2037 | } |
| 1752 | // $ANTLR end "rulePartialitySymbol" | 2038 | // $ANTLR end "ruleExpression" |
| 1753 | 2039 | ||
| 1754 | 2040 | ||
| 1755 | // $ANTLR start "entryRuleExistSymbol" | 2041 | // $ANTLR start "entryRuleIfElse" |
| 1756 | // InternalSolverLanguage.g:612:1: entryRuleExistSymbol returns [EObject current=null] : iv_ruleExistSymbol= ruleExistSymbol EOF ; | 2042 | // InternalSolverLanguageParser.g:810:1: entryRuleIfElse returns [EObject current=null] : iv_ruleIfElse= ruleIfElse EOF ; |
| 1757 | public final EObject entryRuleExistSymbol() throws RecognitionException { | 2043 | public final EObject entryRuleIfElse() throws RecognitionException { |
| 1758 | EObject current = null; | 2044 | EObject current = null; |
| 1759 | 2045 | ||
| 1760 | EObject iv_ruleExistSymbol = null; | 2046 | EObject iv_ruleIfElse = null; |
| 1761 | 2047 | ||
| 1762 | 2048 | ||
| 1763 | try { | 2049 | try { |
| 1764 | // InternalSolverLanguage.g:612:52: (iv_ruleExistSymbol= ruleExistSymbol EOF ) | 2050 | // InternalSolverLanguageParser.g:810:47: (iv_ruleIfElse= ruleIfElse EOF ) |
| 1765 | // InternalSolverLanguage.g:613:2: iv_ruleExistSymbol= ruleExistSymbol EOF | 2051 | // InternalSolverLanguageParser.g:811:2: iv_ruleIfElse= ruleIfElse EOF |
| 1766 | { | 2052 | { |
| 1767 | newCompositeNode(grammarAccess.getExistSymbolRule()); | 2053 | newCompositeNode(grammarAccess.getIfElseRule()); |
| 1768 | pushFollow(FOLLOW_1); | 2054 | pushFollow(FOLLOW_1); |
| 1769 | iv_ruleExistSymbol=ruleExistSymbol(); | 2055 | iv_ruleIfElse=ruleIfElse(); |
| 1770 | 2056 | ||
| 1771 | state._fsp--; | 2057 | state._fsp--; |
| 1772 | 2058 | ||
| 1773 | current =iv_ruleExistSymbol; | 2059 | current =iv_ruleIfElse; |
| 1774 | match(input,EOF,FOLLOW_2); | 2060 | match(input,EOF,FOLLOW_2); |
| 1775 | 2061 | ||
| 1776 | } | 2062 | } |
| @@ -1785,38 +2071,136 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1785 | } | 2071 | } |
| 1786 | return current; | 2072 | return current; |
| 1787 | } | 2073 | } |
| 1788 | // $ANTLR end "entryRuleExistSymbol" | 2074 | // $ANTLR end "entryRuleIfElse" |
| 1789 | 2075 | ||
| 1790 | 2076 | ||
| 1791 | // $ANTLR start "ruleExistSymbol" | 2077 | // $ANTLR start "ruleIfElse" |
| 1792 | // InternalSolverLanguage.g:619:1: ruleExistSymbol returns [EObject current=null] : (otherlv_0= 'exists' () ) ; | 2078 | // InternalSolverLanguageParser.g:817:1: ruleIfElse returns [EObject current=null] : (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ; |
| 1793 | public final EObject ruleExistSymbol() throws RecognitionException { | 2079 | public final EObject ruleIfElse() throws RecognitionException { |
| 1794 | EObject current = null; | 2080 | EObject current = null; |
| 1795 | 2081 | ||
| 1796 | Token otherlv_0=null; | 2082 | Token otherlv_0=null; |
| 2083 | Token otherlv_2=null; | ||
| 2084 | Token otherlv_4=null; | ||
| 2085 | EObject lv_condition_1_0 = null; | ||
| 2086 | |||
| 2087 | EObject lv_then_3_0 = null; | ||
| 2088 | |||
| 2089 | EObject lv_else_5_0 = null; | ||
| 2090 | |||
| 1797 | 2091 | ||
| 1798 | 2092 | ||
| 1799 | enterRule(); | 2093 | enterRule(); |
| 1800 | 2094 | ||
| 1801 | try { | 2095 | try { |
| 1802 | // InternalSolverLanguage.g:625:2: ( (otherlv_0= 'exists' () ) ) | 2096 | // InternalSolverLanguageParser.g:823:2: ( (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ) |
| 1803 | // InternalSolverLanguage.g:626:2: (otherlv_0= 'exists' () ) | 2097 | // InternalSolverLanguageParser.g:824:2: (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) |
| 1804 | { | 2098 | { |
| 1805 | // InternalSolverLanguage.g:626:2: (otherlv_0= 'exists' () ) | 2099 | // InternalSolverLanguageParser.g:824:2: (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) |
| 1806 | // InternalSolverLanguage.g:627:3: otherlv_0= 'exists' () | 2100 | // InternalSolverLanguageParser.g:825:3: otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) |
| 1807 | { | 2101 | { |
| 1808 | otherlv_0=(Token)match(input,21,FOLLOW_2); | 2102 | otherlv_0=(Token)match(input,If,FOLLOW_6); |
| 1809 | 2103 | ||
| 1810 | newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); | 2104 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); |
| 1811 | 2105 | ||
| 1812 | // InternalSolverLanguage.g:631:3: () | 2106 | // InternalSolverLanguageParser.g:829:3: ( (lv_condition_1_0= ruleExpression ) ) |
| 1813 | // InternalSolverLanguage.g:632:4: | 2107 | // InternalSolverLanguageParser.g:830:4: (lv_condition_1_0= ruleExpression ) |
| 2108 | { | ||
| 2109 | // InternalSolverLanguageParser.g:830:4: (lv_condition_1_0= ruleExpression ) | ||
| 2110 | // InternalSolverLanguageParser.g:831:5: lv_condition_1_0= ruleExpression | ||
| 1814 | { | 2111 | { |
| 1815 | 2112 | ||
| 1816 | current = forceCreateModelElement( | 2113 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); |
| 1817 | grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), | 2114 | |
| 1818 | current); | 2115 | pushFollow(FOLLOW_15); |
| 1819 | 2116 | lv_condition_1_0=ruleExpression(); | |
| 2117 | |||
| 2118 | state._fsp--; | ||
| 2119 | |||
| 2120 | |||
| 2121 | if (current==null) { | ||
| 2122 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2123 | } | ||
| 2124 | set( | ||
| 2125 | current, | ||
| 2126 | "condition", | ||
| 2127 | lv_condition_1_0, | ||
| 2128 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2129 | afterParserOrEnumRuleCall(); | ||
| 2130 | |||
| 2131 | |||
| 2132 | } | ||
| 2133 | |||
| 2134 | |||
| 2135 | } | ||
| 2136 | |||
| 2137 | otherlv_2=(Token)match(input,Then,FOLLOW_6); | ||
| 2138 | |||
| 2139 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | ||
| 2140 | |||
| 2141 | // InternalSolverLanguageParser.g:852:3: ( (lv_then_3_0= ruleExpression ) ) | ||
| 2142 | // InternalSolverLanguageParser.g:853:4: (lv_then_3_0= ruleExpression ) | ||
| 2143 | { | ||
| 2144 | // InternalSolverLanguageParser.g:853:4: (lv_then_3_0= ruleExpression ) | ||
| 2145 | // InternalSolverLanguageParser.g:854:5: lv_then_3_0= ruleExpression | ||
| 2146 | { | ||
| 2147 | |||
| 2148 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
| 2149 | |||
| 2150 | pushFollow(FOLLOW_16); | ||
| 2151 | lv_then_3_0=ruleExpression(); | ||
| 2152 | |||
| 2153 | state._fsp--; | ||
| 2154 | |||
| 2155 | |||
| 2156 | if (current==null) { | ||
| 2157 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2158 | } | ||
| 2159 | set( | ||
| 2160 | current, | ||
| 2161 | "then", | ||
| 2162 | lv_then_3_0, | ||
| 2163 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2164 | afterParserOrEnumRuleCall(); | ||
| 2165 | |||
| 2166 | |||
| 2167 | } | ||
| 2168 | |||
| 2169 | |||
| 2170 | } | ||
| 2171 | |||
| 2172 | otherlv_4=(Token)match(input,Else,FOLLOW_6); | ||
| 2173 | |||
| 2174 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | ||
| 2175 | |||
| 2176 | // InternalSolverLanguageParser.g:875:3: ( (lv_else_5_0= ruleExpression ) ) | ||
| 2177 | // InternalSolverLanguageParser.g:876:4: (lv_else_5_0= ruleExpression ) | ||
| 2178 | { | ||
| 2179 | // InternalSolverLanguageParser.g:876:4: (lv_else_5_0= ruleExpression ) | ||
| 2180 | // InternalSolverLanguageParser.g:877:5: lv_else_5_0= ruleExpression | ||
| 2181 | { | ||
| 2182 | |||
| 2183 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
| 2184 | |||
| 2185 | pushFollow(FOLLOW_2); | ||
| 2186 | lv_else_5_0=ruleExpression(); | ||
| 2187 | |||
| 2188 | state._fsp--; | ||
| 2189 | |||
| 2190 | |||
| 2191 | if (current==null) { | ||
| 2192 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | ||
| 2193 | } | ||
| 2194 | set( | ||
| 2195 | current, | ||
| 2196 | "else", | ||
| 2197 | lv_else_5_0, | ||
| 2198 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 2199 | afterParserOrEnumRuleCall(); | ||
| 2200 | |||
| 2201 | |||
| 2202 | } | ||
| 2203 | |||
| 1820 | 2204 | ||
| 1821 | } | 2205 | } |
| 1822 | 2206 | ||
| @@ -1839,28 +2223,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1839 | } | 2223 | } |
| 1840 | return current; | 2224 | return current; |
| 1841 | } | 2225 | } |
| 1842 | // $ANTLR end "ruleExistSymbol" | 2226 | // $ANTLR end "ruleIfElse" |
| 1843 | 2227 | ||
| 1844 | 2228 | ||
| 1845 | // $ANTLR start "entryRuleEqualsSymbol" | 2229 | // $ANTLR start "entryRuleDisjunctiveExpression" |
| 1846 | // InternalSolverLanguage.g:642:1: entryRuleEqualsSymbol returns [EObject current=null] : iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ; | 2230 | // InternalSolverLanguageParser.g:898:1: entryRuleDisjunctiveExpression returns [EObject current=null] : iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ; |
| 1847 | public final EObject entryRuleEqualsSymbol() throws RecognitionException { | 2231 | public final EObject entryRuleDisjunctiveExpression() throws RecognitionException { |
| 1848 | EObject current = null; | 2232 | EObject current = null; |
| 1849 | 2233 | ||
| 1850 | EObject iv_ruleEqualsSymbol = null; | 2234 | EObject iv_ruleDisjunctiveExpression = null; |
| 1851 | 2235 | ||
| 1852 | 2236 | ||
| 1853 | try { | 2237 | try { |
| 1854 | // InternalSolverLanguage.g:642:53: (iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ) | 2238 | // InternalSolverLanguageParser.g:898:62: (iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ) |
| 1855 | // InternalSolverLanguage.g:643:2: iv_ruleEqualsSymbol= ruleEqualsSymbol EOF | 2239 | // InternalSolverLanguageParser.g:899:2: iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF |
| 1856 | { | 2240 | { |
| 1857 | newCompositeNode(grammarAccess.getEqualsSymbolRule()); | 2241 | newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); |
| 1858 | pushFollow(FOLLOW_1); | 2242 | pushFollow(FOLLOW_1); |
| 1859 | iv_ruleEqualsSymbol=ruleEqualsSymbol(); | 2243 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression(); |
| 1860 | 2244 | ||
| 1861 | state._fsp--; | 2245 | state._fsp--; |
| 1862 | 2246 | ||
| 1863 | current =iv_ruleEqualsSymbol; | 2247 | current =iv_ruleDisjunctiveExpression; |
| 1864 | match(input,EOF,FOLLOW_2); | 2248 | match(input,EOF,FOLLOW_2); |
| 1865 | 2249 | ||
| 1866 | } | 2250 | } |
| @@ -1875,38 +2259,274 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1875 | } | 2259 | } |
| 1876 | return current; | 2260 | return current; |
| 1877 | } | 2261 | } |
| 1878 | // $ANTLR end "entryRuleEqualsSymbol" | 2262 | // $ANTLR end "entryRuleDisjunctiveExpression" |
| 1879 | 2263 | ||
| 1880 | 2264 | ||
| 1881 | // $ANTLR start "ruleEqualsSymbol" | 2265 | // $ANTLR start "ruleDisjunctiveExpression" |
| 1882 | // InternalSolverLanguage.g:649:1: ruleEqualsSymbol returns [EObject current=null] : (otherlv_0= 'equals' () ) ; | 2266 | // InternalSolverLanguageParser.g:905:1: ruleDisjunctiveExpression returns [EObject current=null] : (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ; |
| 1883 | public final EObject ruleEqualsSymbol() throws RecognitionException { | 2267 | public final EObject ruleDisjunctiveExpression() throws RecognitionException { |
| 1884 | EObject current = null; | 2268 | EObject current = null; |
| 1885 | 2269 | ||
| 1886 | Token otherlv_0=null; | 2270 | Token otherlv_2=null; |
| 2271 | Token otherlv_5=null; | ||
| 2272 | Token otherlv_8=null; | ||
| 2273 | EObject this_ConjunctiveExpression_0 = null; | ||
| 2274 | |||
| 2275 | EObject lv_children_3_0 = null; | ||
| 2276 | |||
| 2277 | EObject lv_body_6_0 = null; | ||
| 2278 | |||
| 2279 | EObject lv_cases_9_0 = null; | ||
| 2280 | |||
| 1887 | 2281 | ||
| 1888 | 2282 | ||
| 1889 | enterRule(); | 2283 | enterRule(); |
| 1890 | 2284 | ||
| 1891 | try { | 2285 | try { |
| 1892 | // InternalSolverLanguage.g:655:2: ( (otherlv_0= 'equals' () ) ) | 2286 | // InternalSolverLanguageParser.g:911:2: ( (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ) |
| 1893 | // InternalSolverLanguage.g:656:2: (otherlv_0= 'equals' () ) | 2287 | // InternalSolverLanguageParser.g:912:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
| 1894 | { | 2288 | { |
| 1895 | // InternalSolverLanguage.g:656:2: (otherlv_0= 'equals' () ) | 2289 | // InternalSolverLanguageParser.g:912:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
| 1896 | // InternalSolverLanguage.g:657:3: otherlv_0= 'equals' () | 2290 | // InternalSolverLanguageParser.g:913:3: this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? |
| 1897 | { | 2291 | { |
| 1898 | otherlv_0=(Token)match(input,22,FOLLOW_2); | ||
| 1899 | 2292 | ||
| 1900 | newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); | 2293 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); |
| 1901 | 2294 | ||
| 1902 | // InternalSolverLanguage.g:661:3: () | 2295 | pushFollow(FOLLOW_17); |
| 1903 | // InternalSolverLanguage.g:662:4: | 2296 | this_ConjunctiveExpression_0=ruleConjunctiveExpression(); |
| 1904 | { | 2297 | |
| 2298 | state._fsp--; | ||
| 1905 | 2299 | ||
| 1906 | current = forceCreateModelElement( | 2300 | |
| 1907 | grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), | 2301 | current = this_ConjunctiveExpression_0; |
| 1908 | current); | 2302 | afterParserOrEnumRuleCall(); |
| 1909 | 2303 | ||
| 2304 | // InternalSolverLanguageParser.g:921:3: ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? | ||
| 2305 | int alt11=3; | ||
| 2306 | int LA11_0 = input.LA(1); | ||
| 2307 | |||
| 2308 | if ( (LA11_0==Semicolon) ) { | ||
| 2309 | alt11=1; | ||
| 2310 | } | ||
| 2311 | else if ( (LA11_0==HyphenMinusGreaterThanSign) ) { | ||
| 2312 | alt11=2; | ||
| 2313 | } | ||
| 2314 | switch (alt11) { | ||
| 2315 | case 1 : | ||
| 2316 | // InternalSolverLanguageParser.g:922:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
| 2317 | { | ||
| 2318 | // InternalSolverLanguageParser.g:922:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
| 2319 | // InternalSolverLanguageParser.g:923:5: () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
| 2320 | { | ||
| 2321 | // InternalSolverLanguageParser.g:923:5: () | ||
| 2322 | // InternalSolverLanguageParser.g:924:6: | ||
| 2323 | { | ||
| 2324 | |||
| 2325 | current = forceCreateModelElementAndAdd( | ||
| 2326 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
| 2327 | current); | ||
| 2328 | |||
| 2329 | |||
| 2330 | } | ||
| 2331 | |||
| 2332 | // InternalSolverLanguageParser.g:930:5: (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
| 2333 | int cnt9=0; | ||
| 2334 | loop9: | ||
| 2335 | do { | ||
| 2336 | int alt9=2; | ||
| 2337 | int LA9_0 = input.LA(1); | ||
| 2338 | |||
| 2339 | if ( (LA9_0==Semicolon) ) { | ||
| 2340 | alt9=1; | ||
| 2341 | } | ||
| 2342 | |||
| 2343 | |||
| 2344 | switch (alt9) { | ||
| 2345 | case 1 : | ||
| 2346 | // InternalSolverLanguageParser.g:931:6: otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
| 2347 | { | ||
| 2348 | otherlv_2=(Token)match(input,Semicolon,FOLLOW_6); | ||
| 2349 | |||
| 2350 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
| 2351 | |||
| 2352 | // InternalSolverLanguageParser.g:935:6: ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
| 2353 | // InternalSolverLanguageParser.g:936:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
| 2354 | { | ||
| 2355 | // InternalSolverLanguageParser.g:936:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
| 2356 | // InternalSolverLanguageParser.g:937:8: lv_children_3_0= ruleConjunctiveExpression | ||
| 2357 | { | ||
| 2358 | |||
| 2359 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
| 2360 | |||
| 2361 | pushFollow(FOLLOW_18); | ||
| 2362 | lv_children_3_0=ruleConjunctiveExpression(); | ||
| 2363 | |||
| 2364 | state._fsp--; | ||
| 2365 | |||
| 2366 | |||
| 2367 | if (current==null) { | ||
| 2368 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2369 | } | ||
| 2370 | add( | ||
| 2371 | current, | ||
| 2372 | "children", | ||
| 2373 | lv_children_3_0, | ||
| 2374 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2375 | afterParserOrEnumRuleCall(); | ||
| 2376 | |||
| 2377 | |||
| 2378 | } | ||
| 2379 | |||
| 2380 | |||
| 2381 | } | ||
| 2382 | |||
| 2383 | |||
| 2384 | } | ||
| 2385 | break; | ||
| 2386 | |||
| 2387 | default : | ||
| 2388 | if ( cnt9 >= 1 ) break loop9; | ||
| 2389 | EarlyExitException eee = | ||
| 2390 | new EarlyExitException(9, input); | ||
| 2391 | throw eee; | ||
| 2392 | } | ||
| 2393 | cnt9++; | ||
| 2394 | } while (true); | ||
| 2395 | |||
| 2396 | |||
| 2397 | } | ||
| 2398 | |||
| 2399 | |||
| 2400 | } | ||
| 2401 | break; | ||
| 2402 | case 2 : | ||
| 2403 | // InternalSolverLanguageParser.g:957:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
| 2404 | { | ||
| 2405 | // InternalSolverLanguageParser.g:957:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
| 2406 | // InternalSolverLanguageParser.g:958:5: () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* | ||
| 2407 | { | ||
| 2408 | // InternalSolverLanguageParser.g:958:5: () | ||
| 2409 | // InternalSolverLanguageParser.g:959:6: | ||
| 2410 | { | ||
| 2411 | |||
| 2412 | current = forceCreateModelElementAndSet( | ||
| 2413 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
| 2414 | current); | ||
| 2415 | |||
| 2416 | |||
| 2417 | } | ||
| 2418 | |||
| 2419 | otherlv_5=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_6); | ||
| 2420 | |||
| 2421 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
| 2422 | |||
| 2423 | // InternalSolverLanguageParser.g:969:5: ( (lv_body_6_0= ruleConjunctiveExpression ) ) | ||
| 2424 | // InternalSolverLanguageParser.g:970:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
| 2425 | { | ||
| 2426 | // InternalSolverLanguageParser.g:970:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
| 2427 | // InternalSolverLanguageParser.g:971:7: lv_body_6_0= ruleConjunctiveExpression | ||
| 2428 | { | ||
| 2429 | |||
| 2430 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
| 2431 | |||
| 2432 | pushFollow(FOLLOW_18); | ||
| 2433 | lv_body_6_0=ruleConjunctiveExpression(); | ||
| 2434 | |||
| 2435 | state._fsp--; | ||
| 2436 | |||
| 2437 | |||
| 2438 | if (current==null) { | ||
| 2439 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2440 | } | ||
| 2441 | set( | ||
| 2442 | current, | ||
| 2443 | "body", | ||
| 2444 | lv_body_6_0, | ||
| 2445 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2446 | afterParserOrEnumRuleCall(); | ||
| 2447 | |||
| 2448 | |||
| 2449 | } | ||
| 2450 | |||
| 2451 | |||
| 2452 | } | ||
| 2453 | |||
| 2454 | // InternalSolverLanguageParser.g:988:5: () | ||
| 2455 | // InternalSolverLanguageParser.g:989:6: | ||
| 2456 | { | ||
| 2457 | |||
| 2458 | current = forceCreateModelElementAndAdd( | ||
| 2459 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
| 2460 | current); | ||
| 2461 | |||
| 2462 | |||
| 2463 | } | ||
| 2464 | |||
| 2465 | // InternalSolverLanguageParser.g:995:5: (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* | ||
| 2466 | loop10: | ||
| 2467 | do { | ||
| 2468 | int alt10=2; | ||
| 2469 | int LA10_0 = input.LA(1); | ||
| 2470 | |||
| 2471 | if ( (LA10_0==Semicolon) ) { | ||
| 2472 | alt10=1; | ||
| 2473 | } | ||
| 2474 | |||
| 2475 | |||
| 2476 | switch (alt10) { | ||
| 2477 | case 1 : | ||
| 2478 | // InternalSolverLanguageParser.g:996:6: otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) | ||
| 2479 | { | ||
| 2480 | otherlv_8=(Token)match(input,Semicolon,FOLLOW_6); | ||
| 2481 | |||
| 2482 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
| 2483 | |||
| 2484 | // InternalSolverLanguageParser.g:1000:6: ( (lv_cases_9_0= ruleCase ) ) | ||
| 2485 | // InternalSolverLanguageParser.g:1001:7: (lv_cases_9_0= ruleCase ) | ||
| 2486 | { | ||
| 2487 | // InternalSolverLanguageParser.g:1001:7: (lv_cases_9_0= ruleCase ) | ||
| 2488 | // InternalSolverLanguageParser.g:1002:8: lv_cases_9_0= ruleCase | ||
| 2489 | { | ||
| 2490 | |||
| 2491 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
| 2492 | |||
| 2493 | pushFollow(FOLLOW_18); | ||
| 2494 | lv_cases_9_0=ruleCase(); | ||
| 2495 | |||
| 2496 | state._fsp--; | ||
| 2497 | |||
| 2498 | |||
| 2499 | if (current==null) { | ||
| 2500 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
| 2501 | } | ||
| 2502 | add( | ||
| 2503 | current, | ||
| 2504 | "cases", | ||
| 2505 | lv_cases_9_0, | ||
| 2506 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
| 2507 | afterParserOrEnumRuleCall(); | ||
| 2508 | |||
| 2509 | |||
| 2510 | } | ||
| 2511 | |||
| 2512 | |||
| 2513 | } | ||
| 2514 | |||
| 2515 | |||
| 2516 | } | ||
| 2517 | break; | ||
| 2518 | |||
| 2519 | default : | ||
| 2520 | break loop10; | ||
| 2521 | } | ||
| 2522 | } while (true); | ||
| 2523 | |||
| 2524 | |||
| 2525 | } | ||
| 2526 | |||
| 2527 | |||
| 2528 | } | ||
| 2529 | break; | ||
| 1910 | 2530 | ||
| 1911 | } | 2531 | } |
| 1912 | 2532 | ||
| @@ -1929,28 +2549,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1929 | } | 2549 | } |
| 1930 | return current; | 2550 | return current; |
| 1931 | } | 2551 | } |
| 1932 | // $ANTLR end "ruleEqualsSymbol" | 2552 | // $ANTLR end "ruleDisjunctiveExpression" |
| 1933 | 2553 | ||
| 1934 | 2554 | ||
| 1935 | // $ANTLR start "entryRuleDataSymbol" | 2555 | // $ANTLR start "entryRuleCase" |
| 1936 | // InternalSolverLanguage.g:672:1: entryRuleDataSymbol returns [EObject current=null] : iv_ruleDataSymbol= ruleDataSymbol EOF ; | 2556 | // InternalSolverLanguageParser.g:1026:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ; |
| 1937 | public final EObject entryRuleDataSymbol() throws RecognitionException { | 2557 | public final EObject entryRuleCase() throws RecognitionException { |
| 1938 | EObject current = null; | 2558 | EObject current = null; |
| 1939 | 2559 | ||
| 1940 | EObject iv_ruleDataSymbol = null; | 2560 | EObject iv_ruleCase = null; |
| 1941 | 2561 | ||
| 1942 | 2562 | ||
| 1943 | try { | 2563 | try { |
| 1944 | // InternalSolverLanguage.g:672:51: (iv_ruleDataSymbol= ruleDataSymbol EOF ) | 2564 | // InternalSolverLanguageParser.g:1026:45: (iv_ruleCase= ruleCase EOF ) |
| 1945 | // InternalSolverLanguage.g:673:2: iv_ruleDataSymbol= ruleDataSymbol EOF | 2565 | // InternalSolverLanguageParser.g:1027:2: iv_ruleCase= ruleCase EOF |
| 1946 | { | 2566 | { |
| 1947 | newCompositeNode(grammarAccess.getDataSymbolRule()); | 2567 | newCompositeNode(grammarAccess.getCaseRule()); |
| 1948 | pushFollow(FOLLOW_1); | 2568 | pushFollow(FOLLOW_1); |
| 1949 | iv_ruleDataSymbol=ruleDataSymbol(); | 2569 | iv_ruleCase=ruleCase(); |
| 1950 | 2570 | ||
| 1951 | state._fsp--; | 2571 | state._fsp--; |
| 1952 | 2572 | ||
| 1953 | current =iv_ruleDataSymbol; | 2573 | current =iv_ruleCase; |
| 1954 | match(input,EOF,FOLLOW_2); | 2574 | match(input,EOF,FOLLOW_2); |
| 1955 | 2575 | ||
| 1956 | } | 2576 | } |
| @@ -1965,130 +2585,273 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 1965 | } | 2585 | } |
| 1966 | return current; | 2586 | return current; |
| 1967 | } | 2587 | } |
| 1968 | // $ANTLR end "entryRuleDataSymbol" | 2588 | // $ANTLR end "entryRuleCase" |
| 1969 | 2589 | ||
| 1970 | 2590 | ||
| 1971 | // $ANTLR start "ruleDataSymbol" | 2591 | // $ANTLR start "ruleCase" |
| 1972 | // InternalSolverLanguage.g:679:1: ruleDataSymbol returns [EObject current=null] : (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ; | 2592 | // InternalSolverLanguageParser.g:1033:1: ruleCase returns [EObject current=null] : ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ; |
| 1973 | public final EObject ruleDataSymbol() throws RecognitionException { | 2593 | public final EObject ruleCase() throws RecognitionException { |
| 1974 | EObject current = null; | 2594 | EObject current = null; |
| 1975 | 2595 | ||
| 1976 | EObject this_BooleanSymbol_0 = null; | 2596 | Token otherlv_1=null; |
| 2597 | EObject lv_condition_0_0 = null; | ||
| 1977 | 2598 | ||
| 1978 | EObject this_IntegerSymbol_1 = null; | 2599 | EObject lv_body_2_0 = null; |
| 1979 | 2600 | ||
| 1980 | EObject this_RealSymbol_2 = null; | ||
| 1981 | 2601 | ||
| 1982 | EObject this_StringSymbol_3 = null; | ||
| 1983 | 2602 | ||
| 2603 | enterRule(); | ||
| 1984 | 2604 | ||
| 2605 | try { | ||
| 2606 | // InternalSolverLanguageParser.g:1039:2: ( ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ) | ||
| 2607 | // InternalSolverLanguageParser.g:1040:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
| 2608 | { | ||
| 2609 | // InternalSolverLanguageParser.g:1040:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
| 2610 | // InternalSolverLanguageParser.g:1041:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
| 2611 | { | ||
| 2612 | // InternalSolverLanguageParser.g:1041:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) | ||
| 2613 | // InternalSolverLanguageParser.g:1042:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
| 2614 | { | ||
| 2615 | // InternalSolverLanguageParser.g:1042:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
| 2616 | // InternalSolverLanguageParser.g:1043:5: lv_condition_0_0= ruleConjunctiveExpression | ||
| 2617 | { | ||
| 2618 | |||
| 2619 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
| 2620 | |||
| 2621 | pushFollow(FOLLOW_19); | ||
| 2622 | lv_condition_0_0=ruleConjunctiveExpression(); | ||
| 2623 | |||
| 2624 | state._fsp--; | ||
| 2625 | |||
| 2626 | |||
| 2627 | if (current==null) { | ||
| 2628 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 2629 | } | ||
| 2630 | set( | ||
| 2631 | current, | ||
| 2632 | "condition", | ||
| 2633 | lv_condition_0_0, | ||
| 2634 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2635 | afterParserOrEnumRuleCall(); | ||
| 2636 | |||
| 2637 | |||
| 2638 | } | ||
| 2639 | |||
| 2640 | |||
| 2641 | } | ||
| 2642 | |||
| 2643 | otherlv_1=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_6); | ||
| 2644 | |||
| 2645 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
| 2646 | |||
| 2647 | // InternalSolverLanguageParser.g:1064:3: ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
| 2648 | // InternalSolverLanguageParser.g:1065:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
| 2649 | { | ||
| 2650 | // InternalSolverLanguageParser.g:1065:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
| 2651 | // InternalSolverLanguageParser.g:1066:5: lv_body_2_0= ruleConjunctiveExpression | ||
| 2652 | { | ||
| 2653 | |||
| 2654 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
| 2655 | |||
| 2656 | pushFollow(FOLLOW_2); | ||
| 2657 | lv_body_2_0=ruleConjunctiveExpression(); | ||
| 2658 | |||
| 2659 | state._fsp--; | ||
| 2660 | |||
| 2661 | |||
| 2662 | if (current==null) { | ||
| 2663 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
| 2664 | } | ||
| 2665 | set( | ||
| 2666 | current, | ||
| 2667 | "body", | ||
| 2668 | lv_body_2_0, | ||
| 2669 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 2670 | afterParserOrEnumRuleCall(); | ||
| 2671 | |||
| 2672 | |||
| 2673 | } | ||
| 2674 | |||
| 2675 | |||
| 2676 | } | ||
| 2677 | |||
| 2678 | |||
| 2679 | } | ||
| 2680 | |||
| 2681 | |||
| 2682 | } | ||
| 2683 | |||
| 2684 | |||
| 2685 | leaveRule(); | ||
| 2686 | |||
| 2687 | } | ||
| 2688 | |||
| 2689 | catch (RecognitionException re) { | ||
| 2690 | recover(input,re); | ||
| 2691 | appendSkippedTokens(); | ||
| 2692 | } | ||
| 2693 | finally { | ||
| 2694 | } | ||
| 2695 | return current; | ||
| 2696 | } | ||
| 2697 | // $ANTLR end "ruleCase" | ||
| 2698 | |||
| 2699 | |||
| 2700 | // $ANTLR start "entryRuleConjunctiveExpression" | ||
| 2701 | // InternalSolverLanguageParser.g:1087:1: entryRuleConjunctiveExpression returns [EObject current=null] : iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ; | ||
| 2702 | public final EObject entryRuleConjunctiveExpression() throws RecognitionException { | ||
| 2703 | EObject current = null; | ||
| 2704 | |||
| 2705 | EObject iv_ruleConjunctiveExpression = null; | ||
| 1985 | 2706 | ||
| 1986 | enterRule(); | ||
| 1987 | 2707 | ||
| 1988 | try { | 2708 | try { |
| 1989 | // InternalSolverLanguage.g:685:2: ( (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ) | 2709 | // InternalSolverLanguageParser.g:1087:62: (iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ) |
| 1990 | // InternalSolverLanguage.g:686:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) | 2710 | // InternalSolverLanguageParser.g:1088:2: iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF |
| 1991 | { | 2711 | { |
| 1992 | // InternalSolverLanguage.g:686:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) | 2712 | newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); |
| 1993 | int alt13=4; | 2713 | pushFollow(FOLLOW_1); |
| 1994 | switch ( input.LA(1) ) { | 2714 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression(); |
| 1995 | case 23: | 2715 | |
| 1996 | { | 2716 | state._fsp--; |
| 1997 | alt13=1; | 2717 | |
| 1998 | } | 2718 | current =iv_ruleConjunctiveExpression; |
| 1999 | break; | 2719 | match(input,EOF,FOLLOW_2); |
| 2000 | case 24: | ||
| 2001 | { | ||
| 2002 | alt13=2; | ||
| 2003 | } | ||
| 2004 | break; | ||
| 2005 | case 25: | ||
| 2006 | { | ||
| 2007 | alt13=3; | ||
| 2008 | } | ||
| 2009 | break; | ||
| 2010 | case 26: | ||
| 2011 | { | ||
| 2012 | alt13=4; | ||
| 2013 | } | ||
| 2014 | break; | ||
| 2015 | default: | ||
| 2016 | NoViableAltException nvae = | ||
| 2017 | new NoViableAltException("", 13, 0, input); | ||
| 2018 | 2720 | ||
| 2019 | throw nvae; | ||
| 2020 | } | 2721 | } |
| 2021 | 2722 | ||
| 2723 | } | ||
| 2724 | |||
| 2725 | catch (RecognitionException re) { | ||
| 2726 | recover(input,re); | ||
| 2727 | appendSkippedTokens(); | ||
| 2728 | } | ||
| 2729 | finally { | ||
| 2730 | } | ||
| 2731 | return current; | ||
| 2732 | } | ||
| 2733 | // $ANTLR end "entryRuleConjunctiveExpression" | ||
| 2734 | |||
| 2735 | |||
| 2736 | // $ANTLR start "ruleConjunctiveExpression" | ||
| 2737 | // InternalSolverLanguageParser.g:1094:1: ruleConjunctiveExpression returns [EObject current=null] : (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ; | ||
| 2738 | public final EObject ruleConjunctiveExpression() throws RecognitionException { | ||
| 2739 | EObject current = null; | ||
| 2740 | |||
| 2741 | Token otherlv_2=null; | ||
| 2742 | EObject this_ComparisonExpression_0 = null; | ||
| 2743 | |||
| 2744 | EObject lv_children_3_0 = null; | ||
| 2745 | |||
| 2746 | |||
| 2747 | |||
| 2748 | enterRule(); | ||
| 2749 | |||
| 2750 | try { | ||
| 2751 | // InternalSolverLanguageParser.g:1100:2: ( (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ) | ||
| 2752 | // InternalSolverLanguageParser.g:1101:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | ||
| 2753 | { | ||
| 2754 | // InternalSolverLanguageParser.g:1101:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | ||
| 2755 | // InternalSolverLanguageParser.g:1102:3: this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | ||
| 2756 | { | ||
| 2757 | |||
| 2758 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
| 2759 | |||
| 2760 | pushFollow(FOLLOW_20); | ||
| 2761 | this_ComparisonExpression_0=ruleComparisonExpression(); | ||
| 2762 | |||
| 2763 | state._fsp--; | ||
| 2764 | |||
| 2765 | |||
| 2766 | current = this_ComparisonExpression_0; | ||
| 2767 | afterParserOrEnumRuleCall(); | ||
| 2768 | |||
| 2769 | // InternalSolverLanguageParser.g:1110:3: ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | ||
| 2770 | int alt13=2; | ||
| 2771 | int LA13_0 = input.LA(1); | ||
| 2772 | |||
| 2773 | if ( (LA13_0==Comma) ) { | ||
| 2774 | alt13=1; | ||
| 2775 | } | ||
| 2022 | switch (alt13) { | 2776 | switch (alt13) { |
| 2023 | case 1 : | 2777 | case 1 : |
| 2024 | // InternalSolverLanguage.g:687:3: this_BooleanSymbol_0= ruleBooleanSymbol | 2778 | // InternalSolverLanguageParser.g:1111:4: () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
| 2779 | { | ||
| 2780 | // InternalSolverLanguageParser.g:1111:4: () | ||
| 2781 | // InternalSolverLanguageParser.g:1112:5: | ||
| 2025 | { | 2782 | { |
| 2026 | 2783 | ||
| 2027 | newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); | 2784 | current = forceCreateModelElementAndAdd( |
| 2028 | 2785 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | |
| 2029 | pushFollow(FOLLOW_2); | 2786 | current); |
| 2030 | this_BooleanSymbol_0=ruleBooleanSymbol(); | 2787 | |
| 2031 | |||
| 2032 | state._fsp--; | ||
| 2033 | 2788 | ||
| 2789 | } | ||
| 2034 | 2790 | ||
| 2035 | current = this_BooleanSymbol_0; | 2791 | // InternalSolverLanguageParser.g:1118:4: (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
| 2036 | afterParserOrEnumRuleCall(); | 2792 | int cnt12=0; |
| 2037 | 2793 | loop12: | |
| 2794 | do { | ||
| 2795 | int alt12=2; | ||
| 2796 | int LA12_0 = input.LA(1); | ||
| 2038 | 2797 | ||
| 2039 | } | 2798 | if ( (LA12_0==Comma) ) { |
| 2040 | break; | 2799 | alt12=1; |
| 2041 | case 2 : | 2800 | } |
| 2042 | // InternalSolverLanguage.g:696:3: this_IntegerSymbol_1= ruleIntegerSymbol | ||
| 2043 | { | ||
| 2044 | 2801 | ||
| 2045 | newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); | ||
| 2046 | |||
| 2047 | pushFollow(FOLLOW_2); | ||
| 2048 | this_IntegerSymbol_1=ruleIntegerSymbol(); | ||
| 2049 | 2802 | ||
| 2050 | state._fsp--; | 2803 | switch (alt12) { |
| 2804 | case 1 : | ||
| 2805 | // InternalSolverLanguageParser.g:1119:5: otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) | ||
| 2806 | { | ||
| 2807 | otherlv_2=(Token)match(input,Comma,FOLLOW_6); | ||
| 2051 | 2808 | ||
| 2809 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
| 2810 | |||
| 2811 | // InternalSolverLanguageParser.g:1123:5: ( (lv_children_3_0= ruleComparisonExpression ) ) | ||
| 2812 | // InternalSolverLanguageParser.g:1124:6: (lv_children_3_0= ruleComparisonExpression ) | ||
| 2813 | { | ||
| 2814 | // InternalSolverLanguageParser.g:1124:6: (lv_children_3_0= ruleComparisonExpression ) | ||
| 2815 | // InternalSolverLanguageParser.g:1125:7: lv_children_3_0= ruleComparisonExpression | ||
| 2816 | { | ||
| 2052 | 2817 | ||
| 2053 | current = this_IntegerSymbol_1; | 2818 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); |
| 2054 | afterParserOrEnumRuleCall(); | 2819 | |
| 2055 | 2820 | pushFollow(FOLLOW_20); | |
| 2821 | lv_children_3_0=ruleComparisonExpression(); | ||
| 2056 | 2822 | ||
| 2057 | } | 2823 | state._fsp--; |
| 2058 | break; | ||
| 2059 | case 3 : | ||
| 2060 | // InternalSolverLanguage.g:705:3: this_RealSymbol_2= ruleRealSymbol | ||
| 2061 | { | ||
| 2062 | 2824 | ||
| 2063 | newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); | ||
| 2064 | |||
| 2065 | pushFollow(FOLLOW_2); | ||
| 2066 | this_RealSymbol_2=ruleRealSymbol(); | ||
| 2067 | 2825 | ||
| 2068 | state._fsp--; | 2826 | if (current==null) { |
| 2827 | current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
| 2828 | } | ||
| 2829 | add( | ||
| 2830 | current, | ||
| 2831 | "children", | ||
| 2832 | lv_children_3_0, | ||
| 2833 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 2834 | afterParserOrEnumRuleCall(); | ||
| 2835 | |||
| 2069 | 2836 | ||
| 2837 | } | ||
| 2070 | 2838 | ||
| 2071 | current = this_RealSymbol_2; | ||
| 2072 | afterParserOrEnumRuleCall(); | ||
| 2073 | |||
| 2074 | 2839 | ||
| 2075 | } | 2840 | } |
| 2076 | break; | ||
| 2077 | case 4 : | ||
| 2078 | // InternalSolverLanguage.g:714:3: this_StringSymbol_3= ruleStringSymbol | ||
| 2079 | { | ||
| 2080 | 2841 | ||
| 2081 | newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); | ||
| 2082 | |||
| 2083 | pushFollow(FOLLOW_2); | ||
| 2084 | this_StringSymbol_3=ruleStringSymbol(); | ||
| 2085 | 2842 | ||
| 2086 | state._fsp--; | 2843 | } |
| 2844 | break; | ||
| 2087 | 2845 | ||
| 2846 | default : | ||
| 2847 | if ( cnt12 >= 1 ) break loop12; | ||
| 2848 | EarlyExitException eee = | ||
| 2849 | new EarlyExitException(12, input); | ||
| 2850 | throw eee; | ||
| 2851 | } | ||
| 2852 | cnt12++; | ||
| 2853 | } while (true); | ||
| 2088 | 2854 | ||
| 2089 | current = this_StringSymbol_3; | ||
| 2090 | afterParserOrEnumRuleCall(); | ||
| 2091 | |||
| 2092 | 2855 | ||
| 2093 | } | 2856 | } |
| 2094 | break; | 2857 | break; |
| @@ -2099,6 +2862,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2099 | } | 2862 | } |
| 2100 | 2863 | ||
| 2101 | 2864 | ||
| 2865 | } | ||
| 2866 | |||
| 2867 | |||
| 2102 | leaveRule(); | 2868 | leaveRule(); |
| 2103 | 2869 | ||
| 2104 | } | 2870 | } |
| @@ -2111,28 +2877,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2111 | } | 2877 | } |
| 2112 | return current; | 2878 | return current; |
| 2113 | } | 2879 | } |
| 2114 | // $ANTLR end "ruleDataSymbol" | 2880 | // $ANTLR end "ruleConjunctiveExpression" |
| 2115 | 2881 | ||
| 2116 | 2882 | ||
| 2117 | // $ANTLR start "entryRuleBooleanSymbol" | 2883 | // $ANTLR start "entryRuleComparisonExpression" |
| 2118 | // InternalSolverLanguage.g:726:1: entryRuleBooleanSymbol returns [EObject current=null] : iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ; | 2884 | // InternalSolverLanguageParser.g:1148:1: entryRuleComparisonExpression returns [EObject current=null] : iv_ruleComparisonExpression= ruleComparisonExpression EOF ; |
| 2119 | public final EObject entryRuleBooleanSymbol() throws RecognitionException { | 2885 | public final EObject entryRuleComparisonExpression() throws RecognitionException { |
| 2120 | EObject current = null; | 2886 | EObject current = null; |
| 2121 | 2887 | ||
| 2122 | EObject iv_ruleBooleanSymbol = null; | 2888 | EObject iv_ruleComparisonExpression = null; |
| 2123 | 2889 | ||
| 2124 | 2890 | ||
| 2125 | try { | 2891 | try { |
| 2126 | // InternalSolverLanguage.g:726:54: (iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ) | 2892 | // InternalSolverLanguageParser.g:1148:61: (iv_ruleComparisonExpression= ruleComparisonExpression EOF ) |
| 2127 | // InternalSolverLanguage.g:727:2: iv_ruleBooleanSymbol= ruleBooleanSymbol EOF | 2893 | // InternalSolverLanguageParser.g:1149:2: iv_ruleComparisonExpression= ruleComparisonExpression EOF |
| 2128 | { | 2894 | { |
| 2129 | newCompositeNode(grammarAccess.getBooleanSymbolRule()); | 2895 | newCompositeNode(grammarAccess.getComparisonExpressionRule()); |
| 2130 | pushFollow(FOLLOW_1); | 2896 | pushFollow(FOLLOW_1); |
| 2131 | iv_ruleBooleanSymbol=ruleBooleanSymbol(); | 2897 | iv_ruleComparisonExpression=ruleComparisonExpression(); |
| 2132 | 2898 | ||
| 2133 | state._fsp--; | 2899 | state._fsp--; |
| 2134 | 2900 | ||
| 2135 | current =iv_ruleBooleanSymbol; | 2901 | current =iv_ruleComparisonExpression; |
| 2136 | match(input,EOF,FOLLOW_2); | 2902 | match(input,EOF,FOLLOW_2); |
| 2137 | 2903 | ||
| 2138 | } | 2904 | } |
| @@ -2147,38 +2913,130 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2147 | } | 2913 | } |
| 2148 | return current; | 2914 | return current; |
| 2149 | } | 2915 | } |
| 2150 | // $ANTLR end "entryRuleBooleanSymbol" | 2916 | // $ANTLR end "entryRuleComparisonExpression" |
| 2151 | 2917 | ||
| 2152 | 2918 | ||
| 2153 | // $ANTLR start "ruleBooleanSymbol" | 2919 | // $ANTLR start "ruleComparisonExpression" |
| 2154 | // InternalSolverLanguage.g:733:1: ruleBooleanSymbol returns [EObject current=null] : (otherlv_0= 'bool' () ) ; | 2920 | // InternalSolverLanguageParser.g:1155:1: ruleComparisonExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; |
| 2155 | public final EObject ruleBooleanSymbol() throws RecognitionException { | 2921 | public final EObject ruleComparisonExpression() throws RecognitionException { |
| 2156 | EObject current = null; | 2922 | EObject current = null; |
| 2157 | 2923 | ||
| 2158 | Token otherlv_0=null; | 2924 | EObject this_AdditiveExpression_0 = null; |
| 2925 | |||
| 2926 | Enumerator lv_op_2_0 = null; | ||
| 2927 | |||
| 2928 | EObject lv_right_3_0 = null; | ||
| 2929 | |||
| 2159 | 2930 | ||
| 2160 | 2931 | ||
| 2161 | enterRule(); | 2932 | enterRule(); |
| 2162 | 2933 | ||
| 2163 | try { | 2934 | try { |
| 2164 | // InternalSolverLanguage.g:739:2: ( (otherlv_0= 'bool' () ) ) | 2935 | // InternalSolverLanguageParser.g:1161:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) |
| 2165 | // InternalSolverLanguage.g:740:2: (otherlv_0= 'bool' () ) | 2936 | // InternalSolverLanguageParser.g:1162:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
| 2166 | { | 2937 | { |
| 2167 | // InternalSolverLanguage.g:740:2: (otherlv_0= 'bool' () ) | 2938 | // InternalSolverLanguageParser.g:1162:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
| 2168 | // InternalSolverLanguage.g:741:3: otherlv_0= 'bool' () | 2939 | // InternalSolverLanguageParser.g:1163:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? |
| 2169 | { | 2940 | { |
| 2170 | otherlv_0=(Token)match(input,23,FOLLOW_2); | ||
| 2171 | 2941 | ||
| 2172 | newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); | 2942 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
| 2173 | 2943 | ||
| 2174 | // InternalSolverLanguage.g:745:3: () | 2944 | pushFollow(FOLLOW_21); |
| 2175 | // InternalSolverLanguage.g:746:4: | 2945 | this_AdditiveExpression_0=ruleAdditiveExpression(); |
| 2176 | { | ||
| 2177 | 2946 | ||
| 2178 | current = forceCreateModelElement( | 2947 | state._fsp--; |
| 2179 | grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), | 2948 | |
| 2180 | current); | 2949 | |
| 2181 | 2950 | current = this_AdditiveExpression_0; | |
| 2951 | afterParserOrEnumRuleCall(); | ||
| 2952 | |||
| 2953 | // InternalSolverLanguageParser.g:1171:3: ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | ||
| 2954 | int alt14=2; | ||
| 2955 | int LA14_0 = input.LA(1); | ||
| 2956 | |||
| 2957 | if ( (LA14_0==ExclamationMarkEqualsSign||(LA14_0>=LessThanSignEqualsSign && LA14_0<=GreaterThanSignEqualsSign)||LA14_0==In||LA14_0==LessThanSign||LA14_0==GreaterThanSign) ) { | ||
| 2958 | alt14=1; | ||
| 2959 | } | ||
| 2960 | switch (alt14) { | ||
| 2961 | case 1 : | ||
| 2962 | // InternalSolverLanguageParser.g:1172:4: () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
| 2963 | { | ||
| 2964 | // InternalSolverLanguageParser.g:1172:4: () | ||
| 2965 | // InternalSolverLanguageParser.g:1173:5: | ||
| 2966 | { | ||
| 2967 | |||
| 2968 | current = forceCreateModelElementAndSet( | ||
| 2969 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), | ||
| 2970 | current); | ||
| 2971 | |||
| 2972 | |||
| 2973 | } | ||
| 2974 | |||
| 2975 | // InternalSolverLanguageParser.g:1179:4: ( (lv_op_2_0= ruleComparisonOperator ) ) | ||
| 2976 | // InternalSolverLanguageParser.g:1180:5: (lv_op_2_0= ruleComparisonOperator ) | ||
| 2977 | { | ||
| 2978 | // InternalSolverLanguageParser.g:1180:5: (lv_op_2_0= ruleComparisonOperator ) | ||
| 2979 | // InternalSolverLanguageParser.g:1181:6: lv_op_2_0= ruleComparisonOperator | ||
| 2980 | { | ||
| 2981 | |||
| 2982 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
| 2983 | |||
| 2984 | pushFollow(FOLLOW_6); | ||
| 2985 | lv_op_2_0=ruleComparisonOperator(); | ||
| 2986 | |||
| 2987 | state._fsp--; | ||
| 2988 | |||
| 2989 | |||
| 2990 | if (current==null) { | ||
| 2991 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 2992 | } | ||
| 2993 | set( | ||
| 2994 | current, | ||
| 2995 | "op", | ||
| 2996 | lv_op_2_0, | ||
| 2997 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
| 2998 | afterParserOrEnumRuleCall(); | ||
| 2999 | |||
| 3000 | |||
| 3001 | } | ||
| 3002 | |||
| 3003 | |||
| 3004 | } | ||
| 3005 | |||
| 3006 | // InternalSolverLanguageParser.g:1198:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
| 3007 | // InternalSolverLanguageParser.g:1199:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
| 3008 | { | ||
| 3009 | // InternalSolverLanguageParser.g:1199:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
| 3010 | // InternalSolverLanguageParser.g:1200:6: lv_right_3_0= ruleAdditiveExpression | ||
| 3011 | { | ||
| 3012 | |||
| 3013 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
| 3014 | |||
| 3015 | pushFollow(FOLLOW_2); | ||
| 3016 | lv_right_3_0=ruleAdditiveExpression(); | ||
| 3017 | |||
| 3018 | state._fsp--; | ||
| 3019 | |||
| 3020 | |||
| 3021 | if (current==null) { | ||
| 3022 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
| 3023 | } | ||
| 3024 | set( | ||
| 3025 | current, | ||
| 3026 | "right", | ||
| 3027 | lv_right_3_0, | ||
| 3028 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
| 3029 | afterParserOrEnumRuleCall(); | ||
| 3030 | |||
| 3031 | |||
| 3032 | } | ||
| 3033 | |||
| 3034 | |||
| 3035 | } | ||
| 3036 | |||
| 3037 | |||
| 3038 | } | ||
| 3039 | break; | ||
| 2182 | 3040 | ||
| 2183 | } | 3041 | } |
| 2184 | 3042 | ||
| @@ -2201,28 +3059,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2201 | } | 3059 | } |
| 2202 | return current; | 3060 | return current; |
| 2203 | } | 3061 | } |
| 2204 | // $ANTLR end "ruleBooleanSymbol" | 3062 | // $ANTLR end "ruleComparisonExpression" |
| 2205 | 3063 | ||
| 2206 | 3064 | ||
| 2207 | // $ANTLR start "entryRuleIntegerSymbol" | 3065 | // $ANTLR start "entryRuleAdditiveExpression" |
| 2208 | // InternalSolverLanguage.g:756:1: entryRuleIntegerSymbol returns [EObject current=null] : iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ; | 3066 | // InternalSolverLanguageParser.g:1222:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; |
| 2209 | public final EObject entryRuleIntegerSymbol() throws RecognitionException { | 3067 | public final EObject entryRuleAdditiveExpression() throws RecognitionException { |
| 2210 | EObject current = null; | 3068 | EObject current = null; |
| 2211 | 3069 | ||
| 2212 | EObject iv_ruleIntegerSymbol = null; | 3070 | EObject iv_ruleAdditiveExpression = null; |
| 2213 | 3071 | ||
| 2214 | 3072 | ||
| 2215 | try { | 3073 | try { |
| 2216 | // InternalSolverLanguage.g:756:54: (iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ) | 3074 | // InternalSolverLanguageParser.g:1222:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) |
| 2217 | // InternalSolverLanguage.g:757:2: iv_ruleIntegerSymbol= ruleIntegerSymbol EOF | 3075 | // InternalSolverLanguageParser.g:1223:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF |
| 2218 | { | 3076 | { |
| 2219 | newCompositeNode(grammarAccess.getIntegerSymbolRule()); | 3077 | newCompositeNode(grammarAccess.getAdditiveExpressionRule()); |
| 2220 | pushFollow(FOLLOW_1); | 3078 | pushFollow(FOLLOW_1); |
| 2221 | iv_ruleIntegerSymbol=ruleIntegerSymbol(); | 3079 | iv_ruleAdditiveExpression=ruleAdditiveExpression(); |
| 2222 | 3080 | ||
| 2223 | state._fsp--; | 3081 | state._fsp--; |
| 2224 | 3082 | ||
| 2225 | current =iv_ruleIntegerSymbol; | 3083 | current =iv_ruleAdditiveExpression; |
| 2226 | match(input,EOF,FOLLOW_2); | 3084 | match(input,EOF,FOLLOW_2); |
| 2227 | 3085 | ||
| 2228 | } | 3086 | } |
| @@ -2237,40 +3095,139 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2237 | } | 3095 | } |
| 2238 | return current; | 3096 | return current; |
| 2239 | } | 3097 | } |
| 2240 | // $ANTLR end "entryRuleIntegerSymbol" | 3098 | // $ANTLR end "entryRuleAdditiveExpression" |
| 2241 | 3099 | ||
| 2242 | 3100 | ||
| 2243 | // $ANTLR start "ruleIntegerSymbol" | 3101 | // $ANTLR start "ruleAdditiveExpression" |
| 2244 | // InternalSolverLanguage.g:763:1: ruleIntegerSymbol returns [EObject current=null] : (otherlv_0= 'int' () ) ; | 3102 | // InternalSolverLanguageParser.g:1229:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; |
| 2245 | public final EObject ruleIntegerSymbol() throws RecognitionException { | 3103 | public final EObject ruleAdditiveExpression() throws RecognitionException { |
| 2246 | EObject current = null; | 3104 | EObject current = null; |
| 2247 | 3105 | ||
| 2248 | Token otherlv_0=null; | 3106 | EObject this_MultiplicativeExpression_0 = null; |
| 3107 | |||
| 3108 | Enumerator lv_op_2_0 = null; | ||
| 3109 | |||
| 3110 | EObject lv_right_3_0 = null; | ||
| 3111 | |||
| 2249 | 3112 | ||
| 2250 | 3113 | ||
| 2251 | enterRule(); | 3114 | enterRule(); |
| 2252 | 3115 | ||
| 2253 | try { | 3116 | try { |
| 2254 | // InternalSolverLanguage.g:769:2: ( (otherlv_0= 'int' () ) ) | 3117 | // InternalSolverLanguageParser.g:1235:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) |
| 2255 | // InternalSolverLanguage.g:770:2: (otherlv_0= 'int' () ) | 3118 | // InternalSolverLanguageParser.g:1236:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
| 2256 | { | 3119 | { |
| 2257 | // InternalSolverLanguage.g:770:2: (otherlv_0= 'int' () ) | 3120 | // InternalSolverLanguageParser.g:1236:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
| 2258 | // InternalSolverLanguage.g:771:3: otherlv_0= 'int' () | 3121 | // InternalSolverLanguageParser.g:1237:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* |
| 2259 | { | 3122 | { |
| 2260 | otherlv_0=(Token)match(input,24,FOLLOW_2); | ||
| 2261 | 3123 | ||
| 2262 | newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); | 3124 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
| 2263 | 3125 | ||
| 2264 | // InternalSolverLanguage.g:775:3: () | 3126 | pushFollow(FOLLOW_22); |
| 2265 | // InternalSolverLanguage.g:776:4: | 3127 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); |
| 2266 | { | ||
| 2267 | 3128 | ||
| 2268 | current = forceCreateModelElement( | 3129 | state._fsp--; |
| 2269 | grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), | ||
| 2270 | current); | ||
| 2271 | |||
| 2272 | 3130 | ||
| 2273 | } | 3131 | |
| 3132 | current = this_MultiplicativeExpression_0; | ||
| 3133 | afterParserOrEnumRuleCall(); | ||
| 3134 | |||
| 3135 | // InternalSolverLanguageParser.g:1245:3: ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | ||
| 3136 | loop15: | ||
| 3137 | do { | ||
| 3138 | int alt15=2; | ||
| 3139 | int LA15_0 = input.LA(1); | ||
| 3140 | |||
| 3141 | if ( (LA15_0==PlusSign||LA15_0==HyphenMinus) ) { | ||
| 3142 | alt15=1; | ||
| 3143 | } | ||
| 3144 | |||
| 3145 | |||
| 3146 | switch (alt15) { | ||
| 3147 | case 1 : | ||
| 3148 | // InternalSolverLanguageParser.g:1246:4: () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
| 3149 | { | ||
| 3150 | // InternalSolverLanguageParser.g:1246:4: () | ||
| 3151 | // InternalSolverLanguageParser.g:1247:5: | ||
| 3152 | { | ||
| 3153 | |||
| 3154 | current = forceCreateModelElementAndSet( | ||
| 3155 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3156 | current); | ||
| 3157 | |||
| 3158 | |||
| 3159 | } | ||
| 3160 | |||
| 3161 | // InternalSolverLanguageParser.g:1253:4: ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) | ||
| 3162 | // InternalSolverLanguageParser.g:1254:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
| 3163 | { | ||
| 3164 | // InternalSolverLanguageParser.g:1254:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
| 3165 | // InternalSolverLanguageParser.g:1255:6: lv_op_2_0= ruleAdditiveBinaryOperator | ||
| 3166 | { | ||
| 3167 | |||
| 3168 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 3169 | |||
| 3170 | pushFollow(FOLLOW_6); | ||
| 3171 | lv_op_2_0=ruleAdditiveBinaryOperator(); | ||
| 3172 | |||
| 3173 | state._fsp--; | ||
| 3174 | |||
| 3175 | |||
| 3176 | if (current==null) { | ||
| 3177 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 3178 | } | ||
| 3179 | set( | ||
| 3180 | current, | ||
| 3181 | "op", | ||
| 3182 | lv_op_2_0, | ||
| 3183 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
| 3184 | afterParserOrEnumRuleCall(); | ||
| 3185 | |||
| 3186 | |||
| 3187 | } | ||
| 3188 | |||
| 3189 | |||
| 3190 | } | ||
| 3191 | |||
| 3192 | // InternalSolverLanguageParser.g:1272:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
| 3193 | // InternalSolverLanguageParser.g:1273:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
| 3194 | { | ||
| 3195 | // InternalSolverLanguageParser.g:1273:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
| 3196 | // InternalSolverLanguageParser.g:1274:6: lv_right_3_0= ruleMultiplicativeExpression | ||
| 3197 | { | ||
| 3198 | |||
| 3199 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
| 3200 | |||
| 3201 | pushFollow(FOLLOW_22); | ||
| 3202 | lv_right_3_0=ruleMultiplicativeExpression(); | ||
| 3203 | |||
| 3204 | state._fsp--; | ||
| 3205 | |||
| 3206 | |||
| 3207 | if (current==null) { | ||
| 3208 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
| 3209 | } | ||
| 3210 | set( | ||
| 3211 | current, | ||
| 3212 | "right", | ||
| 3213 | lv_right_3_0, | ||
| 3214 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
| 3215 | afterParserOrEnumRuleCall(); | ||
| 3216 | |||
| 3217 | |||
| 3218 | } | ||
| 3219 | |||
| 3220 | |||
| 3221 | } | ||
| 3222 | |||
| 3223 | |||
| 3224 | } | ||
| 3225 | break; | ||
| 3226 | |||
| 3227 | default : | ||
| 3228 | break loop15; | ||
| 3229 | } | ||
| 3230 | } while (true); | ||
| 2274 | 3231 | ||
| 2275 | 3232 | ||
| 2276 | } | 3233 | } |
| @@ -2291,28 +3248,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2291 | } | 3248 | } |
| 2292 | return current; | 3249 | return current; |
| 2293 | } | 3250 | } |
| 2294 | // $ANTLR end "ruleIntegerSymbol" | 3251 | // $ANTLR end "ruleAdditiveExpression" |
| 2295 | 3252 | ||
| 2296 | 3253 | ||
| 2297 | // $ANTLR start "entryRuleRealSymbol" | 3254 | // $ANTLR start "entryRuleMultiplicativeExpression" |
| 2298 | // InternalSolverLanguage.g:786:1: entryRuleRealSymbol returns [EObject current=null] : iv_ruleRealSymbol= ruleRealSymbol EOF ; | 3255 | // InternalSolverLanguageParser.g:1296:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; |
| 2299 | public final EObject entryRuleRealSymbol() throws RecognitionException { | 3256 | public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { |
| 2300 | EObject current = null; | 3257 | EObject current = null; |
| 2301 | 3258 | ||
| 2302 | EObject iv_ruleRealSymbol = null; | 3259 | EObject iv_ruleMultiplicativeExpression = null; |
| 2303 | 3260 | ||
| 2304 | 3261 | ||
| 2305 | try { | 3262 | try { |
| 2306 | // InternalSolverLanguage.g:786:51: (iv_ruleRealSymbol= ruleRealSymbol EOF ) | 3263 | // InternalSolverLanguageParser.g:1296:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) |
| 2307 | // InternalSolverLanguage.g:787:2: iv_ruleRealSymbol= ruleRealSymbol EOF | 3264 | // InternalSolverLanguageParser.g:1297:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF |
| 2308 | { | 3265 | { |
| 2309 | newCompositeNode(grammarAccess.getRealSymbolRule()); | 3266 | newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); |
| 2310 | pushFollow(FOLLOW_1); | 3267 | pushFollow(FOLLOW_1); |
| 2311 | iv_ruleRealSymbol=ruleRealSymbol(); | 3268 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); |
| 2312 | 3269 | ||
| 2313 | state._fsp--; | 3270 | state._fsp--; |
| 2314 | 3271 | ||
| 2315 | current =iv_ruleRealSymbol; | 3272 | current =iv_ruleMultiplicativeExpression; |
| 2316 | match(input,EOF,FOLLOW_2); | 3273 | match(input,EOF,FOLLOW_2); |
| 2317 | 3274 | ||
| 2318 | } | 3275 | } |
| @@ -2327,40 +3284,139 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2327 | } | 3284 | } |
| 2328 | return current; | 3285 | return current; |
| 2329 | } | 3286 | } |
| 2330 | // $ANTLR end "entryRuleRealSymbol" | 3287 | // $ANTLR end "entryRuleMultiplicativeExpression" |
| 2331 | 3288 | ||
| 2332 | 3289 | ||
| 2333 | // $ANTLR start "ruleRealSymbol" | 3290 | // $ANTLR start "ruleMultiplicativeExpression" |
| 2334 | // InternalSolverLanguage.g:793:1: ruleRealSymbol returns [EObject current=null] : (otherlv_0= 'real' () ) ; | 3291 | // InternalSolverLanguageParser.g:1303:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ; |
| 2335 | public final EObject ruleRealSymbol() throws RecognitionException { | 3292 | public final EObject ruleMultiplicativeExpression() throws RecognitionException { |
| 2336 | EObject current = null; | 3293 | EObject current = null; |
| 2337 | 3294 | ||
| 2338 | Token otherlv_0=null; | 3295 | EObject this_ExponentialExpression_0 = null; |
| 3296 | |||
| 3297 | Enumerator lv_op_2_0 = null; | ||
| 3298 | |||
| 3299 | EObject lv_right_3_0 = null; | ||
| 3300 | |||
| 2339 | 3301 | ||
| 2340 | 3302 | ||
| 2341 | enterRule(); | 3303 | enterRule(); |
| 2342 | 3304 | ||
| 2343 | try { | 3305 | try { |
| 2344 | // InternalSolverLanguage.g:799:2: ( (otherlv_0= 'real' () ) ) | 3306 | // InternalSolverLanguageParser.g:1309:2: ( (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ) |
| 2345 | // InternalSolverLanguage.g:800:2: (otherlv_0= 'real' () ) | 3307 | // InternalSolverLanguageParser.g:1310:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
| 2346 | { | 3308 | { |
| 2347 | // InternalSolverLanguage.g:800:2: (otherlv_0= 'real' () ) | 3309 | // InternalSolverLanguageParser.g:1310:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
| 2348 | // InternalSolverLanguage.g:801:3: otherlv_0= 'real' () | 3310 | // InternalSolverLanguageParser.g:1311:3: this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* |
| 2349 | { | 3311 | { |
| 2350 | otherlv_0=(Token)match(input,25,FOLLOW_2); | ||
| 2351 | 3312 | ||
| 2352 | newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); | 3313 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
| 2353 | 3314 | ||
| 2354 | // InternalSolverLanguage.g:805:3: () | 3315 | pushFollow(FOLLOW_23); |
| 2355 | // InternalSolverLanguage.g:806:4: | 3316 | this_ExponentialExpression_0=ruleExponentialExpression(); |
| 2356 | { | ||
| 2357 | 3317 | ||
| 2358 | current = forceCreateModelElement( | 3318 | state._fsp--; |
| 2359 | grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), | ||
| 2360 | current); | ||
| 2361 | |||
| 2362 | 3319 | ||
| 2363 | } | 3320 | |
| 3321 | current = this_ExponentialExpression_0; | ||
| 3322 | afterParserOrEnumRuleCall(); | ||
| 3323 | |||
| 3324 | // InternalSolverLanguageParser.g:1319:3: ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | ||
| 3325 | loop16: | ||
| 3326 | do { | ||
| 3327 | int alt16=2; | ||
| 3328 | int LA16_0 = input.LA(1); | ||
| 3329 | |||
| 3330 | if ( (LA16_0==Asterisk||LA16_0==Solidus) ) { | ||
| 3331 | alt16=1; | ||
| 3332 | } | ||
| 3333 | |||
| 3334 | |||
| 3335 | switch (alt16) { | ||
| 3336 | case 1 : | ||
| 3337 | // InternalSolverLanguageParser.g:1320:4: () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3338 | { | ||
| 3339 | // InternalSolverLanguageParser.g:1320:4: () | ||
| 3340 | // InternalSolverLanguageParser.g:1321:5: | ||
| 3341 | { | ||
| 3342 | |||
| 3343 | current = forceCreateModelElementAndSet( | ||
| 3344 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3345 | current); | ||
| 3346 | |||
| 3347 | |||
| 3348 | } | ||
| 3349 | |||
| 3350 | // InternalSolverLanguageParser.g:1327:4: ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) | ||
| 3351 | // InternalSolverLanguageParser.g:1328:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
| 3352 | { | ||
| 3353 | // InternalSolverLanguageParser.g:1328:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
| 3354 | // InternalSolverLanguageParser.g:1329:6: lv_op_2_0= ruleMultiplicativeBinaryOperator | ||
| 3355 | { | ||
| 3356 | |||
| 3357 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
| 3358 | |||
| 3359 | pushFollow(FOLLOW_6); | ||
| 3360 | lv_op_2_0=ruleMultiplicativeBinaryOperator(); | ||
| 3361 | |||
| 3362 | state._fsp--; | ||
| 3363 | |||
| 3364 | |||
| 3365 | if (current==null) { | ||
| 3366 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 3367 | } | ||
| 3368 | set( | ||
| 3369 | current, | ||
| 3370 | "op", | ||
| 3371 | lv_op_2_0, | ||
| 3372 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
| 3373 | afterParserOrEnumRuleCall(); | ||
| 3374 | |||
| 3375 | |||
| 3376 | } | ||
| 3377 | |||
| 3378 | |||
| 3379 | } | ||
| 3380 | |||
| 3381 | // InternalSolverLanguageParser.g:1346:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3382 | // InternalSolverLanguageParser.g:1347:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3383 | { | ||
| 3384 | // InternalSolverLanguageParser.g:1347:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3385 | // InternalSolverLanguageParser.g:1348:6: lv_right_3_0= ruleExponentialExpression | ||
| 3386 | { | ||
| 3387 | |||
| 3388 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 3389 | |||
| 3390 | pushFollow(FOLLOW_23); | ||
| 3391 | lv_right_3_0=ruleExponentialExpression(); | ||
| 3392 | |||
| 3393 | state._fsp--; | ||
| 3394 | |||
| 3395 | |||
| 3396 | if (current==null) { | ||
| 3397 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
| 3398 | } | ||
| 3399 | set( | ||
| 3400 | current, | ||
| 3401 | "right", | ||
| 3402 | lv_right_3_0, | ||
| 3403 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 3404 | afterParserOrEnumRuleCall(); | ||
| 3405 | |||
| 3406 | |||
| 3407 | } | ||
| 3408 | |||
| 3409 | |||
| 3410 | } | ||
| 3411 | |||
| 3412 | |||
| 3413 | } | ||
| 3414 | break; | ||
| 3415 | |||
| 3416 | default : | ||
| 3417 | break loop16; | ||
| 3418 | } | ||
| 3419 | } while (true); | ||
| 2364 | 3420 | ||
| 2365 | 3421 | ||
| 2366 | } | 3422 | } |
| @@ -2381,28 +3437,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2381 | } | 3437 | } |
| 2382 | return current; | 3438 | return current; |
| 2383 | } | 3439 | } |
| 2384 | // $ANTLR end "ruleRealSymbol" | 3440 | // $ANTLR end "ruleMultiplicativeExpression" |
| 2385 | 3441 | ||
| 2386 | 3442 | ||
| 2387 | // $ANTLR start "entryRuleStringSymbol" | 3443 | // $ANTLR start "entryRuleExponentialExpression" |
| 2388 | // InternalSolverLanguage.g:816:1: entryRuleStringSymbol returns [EObject current=null] : iv_ruleStringSymbol= ruleStringSymbol EOF ; | 3444 | // InternalSolverLanguageParser.g:1370:1: entryRuleExponentialExpression returns [EObject current=null] : iv_ruleExponentialExpression= ruleExponentialExpression EOF ; |
| 2389 | public final EObject entryRuleStringSymbol() throws RecognitionException { | 3445 | public final EObject entryRuleExponentialExpression() throws RecognitionException { |
| 2390 | EObject current = null; | 3446 | EObject current = null; |
| 2391 | 3447 | ||
| 2392 | EObject iv_ruleStringSymbol = null; | 3448 | EObject iv_ruleExponentialExpression = null; |
| 2393 | 3449 | ||
| 2394 | 3450 | ||
| 2395 | try { | 3451 | try { |
| 2396 | // InternalSolverLanguage.g:816:53: (iv_ruleStringSymbol= ruleStringSymbol EOF ) | 3452 | // InternalSolverLanguageParser.g:1370:62: (iv_ruleExponentialExpression= ruleExponentialExpression EOF ) |
| 2397 | // InternalSolverLanguage.g:817:2: iv_ruleStringSymbol= ruleStringSymbol EOF | 3453 | // InternalSolverLanguageParser.g:1371:2: iv_ruleExponentialExpression= ruleExponentialExpression EOF |
| 2398 | { | 3454 | { |
| 2399 | newCompositeNode(grammarAccess.getStringSymbolRule()); | 3455 | newCompositeNode(grammarAccess.getExponentialExpressionRule()); |
| 2400 | pushFollow(FOLLOW_1); | 3456 | pushFollow(FOLLOW_1); |
| 2401 | iv_ruleStringSymbol=ruleStringSymbol(); | 3457 | iv_ruleExponentialExpression=ruleExponentialExpression(); |
| 2402 | 3458 | ||
| 2403 | state._fsp--; | 3459 | state._fsp--; |
| 2404 | 3460 | ||
| 2405 | current =iv_ruleStringSymbol; | 3461 | current =iv_ruleExponentialExpression; |
| 2406 | match(input,EOF,FOLLOW_2); | 3462 | match(input,EOF,FOLLOW_2); |
| 2407 | 3463 | ||
| 2408 | } | 3464 | } |
| @@ -2417,38 +3473,130 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2417 | } | 3473 | } |
| 2418 | return current; | 3474 | return current; |
| 2419 | } | 3475 | } |
| 2420 | // $ANTLR end "entryRuleStringSymbol" | 3476 | // $ANTLR end "entryRuleExponentialExpression" |
| 2421 | 3477 | ||
| 2422 | 3478 | ||
| 2423 | // $ANTLR start "ruleStringSymbol" | 3479 | // $ANTLR start "ruleExponentialExpression" |
| 2424 | // InternalSolverLanguage.g:823:1: ruleStringSymbol returns [EObject current=null] : (otherlv_0= 'string' () ) ; | 3480 | // InternalSolverLanguageParser.g:1377:1: ruleExponentialExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ; |
| 2425 | public final EObject ruleStringSymbol() throws RecognitionException { | 3481 | public final EObject ruleExponentialExpression() throws RecognitionException { |
| 2426 | EObject current = null; | 3482 | EObject current = null; |
| 2427 | 3483 | ||
| 2428 | Token otherlv_0=null; | 3484 | EObject this_UnaryExpression_0 = null; |
| 3485 | |||
| 3486 | Enumerator lv_op_2_0 = null; | ||
| 3487 | |||
| 3488 | EObject lv_right_3_0 = null; | ||
| 3489 | |||
| 2429 | 3490 | ||
| 2430 | 3491 | ||
| 2431 | enterRule(); | 3492 | enterRule(); |
| 2432 | 3493 | ||
| 2433 | try { | 3494 | try { |
| 2434 | // InternalSolverLanguage.g:829:2: ( (otherlv_0= 'string' () ) ) | 3495 | // InternalSolverLanguageParser.g:1383:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ) |
| 2435 | // InternalSolverLanguage.g:830:2: (otherlv_0= 'string' () ) | 3496 | // InternalSolverLanguageParser.g:1384:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
| 2436 | { | 3497 | { |
| 2437 | // InternalSolverLanguage.g:830:2: (otherlv_0= 'string' () ) | 3498 | // InternalSolverLanguageParser.g:1384:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
| 2438 | // InternalSolverLanguage.g:831:3: otherlv_0= 'string' () | 3499 | // InternalSolverLanguageParser.g:1385:3: this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? |
| 2439 | { | 3500 | { |
| 2440 | otherlv_0=(Token)match(input,26,FOLLOW_2); | ||
| 2441 | 3501 | ||
| 2442 | newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); | 3502 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
| 2443 | 3503 | ||
| 2444 | // InternalSolverLanguage.g:835:3: () | 3504 | pushFollow(FOLLOW_24); |
| 2445 | // InternalSolverLanguage.g:836:4: | 3505 | this_UnaryExpression_0=ruleUnaryExpression(); |
| 2446 | { | ||
| 2447 | 3506 | ||
| 2448 | current = forceCreateModelElement( | 3507 | state._fsp--; |
| 2449 | grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), | 3508 | |
| 2450 | current); | 3509 | |
| 2451 | 3510 | current = this_UnaryExpression_0; | |
| 3511 | afterParserOrEnumRuleCall(); | ||
| 3512 | |||
| 3513 | // InternalSolverLanguageParser.g:1393:3: ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? | ||
| 3514 | int alt17=2; | ||
| 3515 | int LA17_0 = input.LA(1); | ||
| 3516 | |||
| 3517 | if ( (LA17_0==CircumflexAccent) ) { | ||
| 3518 | alt17=1; | ||
| 3519 | } | ||
| 3520 | switch (alt17) { | ||
| 3521 | case 1 : | ||
| 3522 | // InternalSolverLanguageParser.g:1394:4: () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3523 | { | ||
| 3524 | // InternalSolverLanguageParser.g:1394:4: () | ||
| 3525 | // InternalSolverLanguageParser.g:1395:5: | ||
| 3526 | { | ||
| 3527 | |||
| 3528 | current = forceCreateModelElementAndSet( | ||
| 3529 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
| 3530 | current); | ||
| 3531 | |||
| 3532 | |||
| 3533 | } | ||
| 3534 | |||
| 3535 | // InternalSolverLanguageParser.g:1401:4: ( (lv_op_2_0= ruleExponentialOp ) ) | ||
| 3536 | // InternalSolverLanguageParser.g:1402:5: (lv_op_2_0= ruleExponentialOp ) | ||
| 3537 | { | ||
| 3538 | // InternalSolverLanguageParser.g:1402:5: (lv_op_2_0= ruleExponentialOp ) | ||
| 3539 | // InternalSolverLanguageParser.g:1403:6: lv_op_2_0= ruleExponentialOp | ||
| 3540 | { | ||
| 3541 | |||
| 3542 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
| 3543 | |||
| 3544 | pushFollow(FOLLOW_6); | ||
| 3545 | lv_op_2_0=ruleExponentialOp(); | ||
| 3546 | |||
| 3547 | state._fsp--; | ||
| 3548 | |||
| 3549 | |||
| 3550 | if (current==null) { | ||
| 3551 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 3552 | } | ||
| 3553 | set( | ||
| 3554 | current, | ||
| 3555 | "op", | ||
| 3556 | lv_op_2_0, | ||
| 3557 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
| 3558 | afterParserOrEnumRuleCall(); | ||
| 3559 | |||
| 3560 | |||
| 3561 | } | ||
| 3562 | |||
| 3563 | |||
| 3564 | } | ||
| 3565 | |||
| 3566 | // InternalSolverLanguageParser.g:1420:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
| 3567 | // InternalSolverLanguageParser.g:1421:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3568 | { | ||
| 3569 | // InternalSolverLanguageParser.g:1421:5: (lv_right_3_0= ruleExponentialExpression ) | ||
| 3570 | // InternalSolverLanguageParser.g:1422:6: lv_right_3_0= ruleExponentialExpression | ||
| 3571 | { | ||
| 3572 | |||
| 3573 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
| 3574 | |||
| 3575 | pushFollow(FOLLOW_2); | ||
| 3576 | lv_right_3_0=ruleExponentialExpression(); | ||
| 3577 | |||
| 3578 | state._fsp--; | ||
| 3579 | |||
| 3580 | |||
| 3581 | if (current==null) { | ||
| 3582 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
| 3583 | } | ||
| 3584 | set( | ||
| 3585 | current, | ||
| 3586 | "right", | ||
| 3587 | lv_right_3_0, | ||
| 3588 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
| 3589 | afterParserOrEnumRuleCall(); | ||
| 3590 | |||
| 3591 | |||
| 3592 | } | ||
| 3593 | |||
| 3594 | |||
| 3595 | } | ||
| 3596 | |||
| 3597 | |||
| 3598 | } | ||
| 3599 | break; | ||
| 2452 | 3600 | ||
| 2453 | } | 3601 | } |
| 2454 | 3602 | ||
| @@ -2471,28 +3619,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2471 | } | 3619 | } |
| 2472 | return current; | 3620 | return current; |
| 2473 | } | 3621 | } |
| 2474 | // $ANTLR end "ruleStringSymbol" | 3622 | // $ANTLR end "ruleExponentialExpression" |
| 2475 | 3623 | ||
| 2476 | 3624 | ||
| 2477 | // $ANTLR start "entryRuleComplexObject" | 3625 | // $ANTLR start "entryRuleUnaryExpression" |
| 2478 | // InternalSolverLanguage.g:846:1: entryRuleComplexObject returns [EObject current=null] : iv_ruleComplexObject= ruleComplexObject EOF ; | 3626 | // InternalSolverLanguageParser.g:1444:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; |
| 2479 | public final EObject entryRuleComplexObject() throws RecognitionException { | 3627 | public final EObject entryRuleUnaryExpression() throws RecognitionException { |
| 2480 | EObject current = null; | 3628 | EObject current = null; |
| 2481 | 3629 | ||
| 2482 | EObject iv_ruleComplexObject = null; | 3630 | EObject iv_ruleUnaryExpression = null; |
| 2483 | 3631 | ||
| 2484 | 3632 | ||
| 2485 | try { | 3633 | try { |
| 2486 | // InternalSolverLanguage.g:846:54: (iv_ruleComplexObject= ruleComplexObject EOF ) | 3634 | // InternalSolverLanguageParser.g:1444:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) |
| 2487 | // InternalSolverLanguage.g:847:2: iv_ruleComplexObject= ruleComplexObject EOF | 3635 | // InternalSolverLanguageParser.g:1445:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF |
| 2488 | { | 3636 | { |
| 2489 | newCompositeNode(grammarAccess.getComplexObjectRule()); | 3637 | newCompositeNode(grammarAccess.getUnaryExpressionRule()); |
| 2490 | pushFollow(FOLLOW_1); | 3638 | pushFollow(FOLLOW_1); |
| 2491 | iv_ruleComplexObject=ruleComplexObject(); | 3639 | iv_ruleUnaryExpression=ruleUnaryExpression(); |
| 2492 | 3640 | ||
| 2493 | state._fsp--; | 3641 | state._fsp--; |
| 2494 | 3642 | ||
| 2495 | current =iv_ruleComplexObject; | 3643 | current =iv_ruleUnaryExpression; |
| 2496 | match(input,EOF,FOLLOW_2); | 3644 | match(input,EOF,FOLLOW_2); |
| 2497 | 3645 | ||
| 2498 | } | 3646 | } |
| @@ -2507,111 +3655,145 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2507 | } | 3655 | } |
| 2508 | return current; | 3656 | return current; |
| 2509 | } | 3657 | } |
| 2510 | // $ANTLR end "entryRuleComplexObject" | 3658 | // $ANTLR end "entryRuleUnaryExpression" |
| 2511 | 3659 | ||
| 2512 | 3660 | ||
| 2513 | // $ANTLR start "ruleComplexObject" | 3661 | // $ANTLR start "ruleUnaryExpression" |
| 2514 | // InternalSolverLanguage.g:853:1: ruleComplexObject returns [EObject current=null] : (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ; | 3662 | // InternalSolverLanguageParser.g:1451:1: ruleUnaryExpression returns [EObject current=null] : (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ; |
| 2515 | public final EObject ruleComplexObject() throws RecognitionException { | 3663 | public final EObject ruleUnaryExpression() throws RecognitionException { |
| 2516 | EObject current = null; | 3664 | EObject current = null; |
| 2517 | 3665 | ||
| 2518 | EObject this_Object_0 = null; | 3666 | EObject this_AggregationExpression_0 = null; |
| 2519 | 3667 | ||
| 2520 | EObject this_AllInstances_1 = null; | 3668 | Enumerator lv_op_2_0 = null; |
| 2521 | 3669 | ||
| 2522 | EObject this_AllObjects_2 = null; | 3670 | EObject lv_body_3_0 = null; |
| 2523 | 3671 | ||
| 2524 | 3672 | ||
| 2525 | 3673 | ||
| 2526 | enterRule(); | 3674 | enterRule(); |
| 2527 | 3675 | ||
| 2528 | try { | 3676 | try { |
| 2529 | // InternalSolverLanguage.g:859:2: ( (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ) | 3677 | // InternalSolverLanguageParser.g:1457:2: ( (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ) |
| 2530 | // InternalSolverLanguage.g:860:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) | 3678 | // InternalSolverLanguageParser.g:1458:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
| 2531 | { | 3679 | { |
| 2532 | // InternalSolverLanguage.g:860:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) | 3680 | // InternalSolverLanguageParser.g:1458:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
| 2533 | int alt14=3; | 3681 | int alt18=2; |
| 2534 | switch ( input.LA(1) ) { | 3682 | int LA18_0 = input.LA(1); |
| 2535 | case RULE_INT: | 3683 | |
| 2536 | case RULE_ID: | 3684 | if ( (LA18_0==Unknown||(LA18_0>=Count && LA18_0<=False)||(LA18_0>=Only && LA18_0<=Prod)||LA18_0==True||(LA18_0>=Avg && LA18_0<=Inf)||LA18_0==Max||(LA18_0>=Min && LA18_0<=Sum)||LA18_0==LeftParenthesis||LA18_0==LeftSquareBracket||(LA18_0>=RULE_STRING && LA18_0<=RULE_QUOTED_ID)||(LA18_0>=RULE_ID && LA18_0<=RULE_INT)) ) { |
| 2537 | case RULE_STRING: | 3685 | alt18=1; |
| 2538 | case 11: | 3686 | } |
| 2539 | case 13: | 3687 | else if ( (LA18_0==Current||LA18_0==Must||LA18_0==May||LA18_0==ExclamationMark||LA18_0==PlusSign||LA18_0==HyphenMinus) ) { |
| 2540 | case 14: | 3688 | alt18=2; |
| 2541 | case 27: | 3689 | } |
| 2542 | { | 3690 | else { |
| 2543 | alt14=1; | ||
| 2544 | } | ||
| 2545 | break; | ||
| 2546 | case 20: | ||
| 2547 | { | ||
| 2548 | alt14=2; | ||
| 2549 | } | ||
| 2550 | break; | ||
| 2551 | case 31: | ||
| 2552 | { | ||
| 2553 | alt14=3; | ||
| 2554 | } | ||
| 2555 | break; | ||
| 2556 | default: | ||
| 2557 | NoViableAltException nvae = | 3691 | NoViableAltException nvae = |
| 2558 | new NoViableAltException("", 14, 0, input); | 3692 | new NoViableAltException("", 18, 0, input); |
| 2559 | 3693 | ||
| 2560 | throw nvae; | 3694 | throw nvae; |
| 2561 | } | 3695 | } |
| 2562 | 3696 | switch (alt18) { | |
| 2563 | switch (alt14) { | ||
| 2564 | case 1 : | 3697 | case 1 : |
| 2565 | // InternalSolverLanguage.g:861:3: this_Object_0= ruleObject | 3698 | // InternalSolverLanguageParser.g:1459:3: this_AggregationExpression_0= ruleAggregationExpression |
| 2566 | { | 3699 | { |
| 2567 | 3700 | ||
| 2568 | newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); | 3701 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
| 2569 | 3702 | ||
| 2570 | pushFollow(FOLLOW_2); | 3703 | pushFollow(FOLLOW_2); |
| 2571 | this_Object_0=ruleObject(); | 3704 | this_AggregationExpression_0=ruleAggregationExpression(); |
| 2572 | 3705 | ||
| 2573 | state._fsp--; | 3706 | state._fsp--; |
| 2574 | 3707 | ||
| 2575 | 3708 | ||
| 2576 | current = this_Object_0; | 3709 | current = this_AggregationExpression_0; |
| 2577 | afterParserOrEnumRuleCall(); | 3710 | afterParserOrEnumRuleCall(); |
| 2578 | 3711 | ||
| 2579 | 3712 | ||
| 2580 | } | 3713 | } |
| 2581 | break; | 3714 | break; |
| 2582 | case 2 : | 3715 | case 2 : |
| 2583 | // InternalSolverLanguage.g:870:3: this_AllInstances_1= ruleAllInstances | 3716 | // InternalSolverLanguageParser.g:1468:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) |
| 3717 | { | ||
| 3718 | // InternalSolverLanguageParser.g:1468:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) | ||
| 3719 | // InternalSolverLanguageParser.g:1469:4: () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) | ||
| 3720 | { | ||
| 3721 | // InternalSolverLanguageParser.g:1469:4: () | ||
| 3722 | // InternalSolverLanguageParser.g:1470:5: | ||
| 2584 | { | 3723 | { |
| 2585 | 3724 | ||
| 2586 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); | 3725 | current = forceCreateModelElement( |
| 2587 | 3726 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | |
| 2588 | pushFollow(FOLLOW_2); | 3727 | current); |
| 2589 | this_AllInstances_1=ruleAllInstances(); | 3728 | |
| 3729 | |||
| 3730 | } | ||
| 3731 | |||
| 3732 | // InternalSolverLanguageParser.g:1476:4: ( (lv_op_2_0= ruleUnaryOp ) ) | ||
| 3733 | // InternalSolverLanguageParser.g:1477:5: (lv_op_2_0= ruleUnaryOp ) | ||
| 3734 | { | ||
| 3735 | // InternalSolverLanguageParser.g:1477:5: (lv_op_2_0= ruleUnaryOp ) | ||
| 3736 | // InternalSolverLanguageParser.g:1478:6: lv_op_2_0= ruleUnaryOp | ||
| 3737 | { | ||
| 3738 | |||
| 3739 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
| 3740 | |||
| 3741 | pushFollow(FOLLOW_25); | ||
| 3742 | lv_op_2_0=ruleUnaryOp(); | ||
| 2590 | 3743 | ||
| 2591 | state._fsp--; | 3744 | state._fsp--; |
| 2592 | 3745 | ||
| 2593 | 3746 | ||
| 2594 | current = this_AllInstances_1; | 3747 | if (current==null) { |
| 2595 | afterParserOrEnumRuleCall(); | 3748 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); |
| 2596 | 3749 | } | |
| 3750 | set( | ||
| 3751 | current, | ||
| 3752 | "op", | ||
| 3753 | lv_op_2_0, | ||
| 3754 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | ||
| 3755 | afterParserOrEnumRuleCall(); | ||
| 3756 | |||
| 2597 | 3757 | ||
| 2598 | } | 3758 | } |
| 2599 | break; | 3759 | |
| 2600 | case 3 : | 3760 | |
| 2601 | // InternalSolverLanguage.g:879:3: this_AllObjects_2= ruleAllObjects | 3761 | } |
| 3762 | |||
| 3763 | // InternalSolverLanguageParser.g:1495:4: ( (lv_body_3_0= ruleAggregationExpression ) ) | ||
| 3764 | // InternalSolverLanguageParser.g:1496:5: (lv_body_3_0= ruleAggregationExpression ) | ||
| 3765 | { | ||
| 3766 | // InternalSolverLanguageParser.g:1496:5: (lv_body_3_0= ruleAggregationExpression ) | ||
| 3767 | // InternalSolverLanguageParser.g:1497:6: lv_body_3_0= ruleAggregationExpression | ||
| 2602 | { | 3768 | { |
| 2603 | 3769 | ||
| 2604 | newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); | 3770 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); |
| 2605 | 3771 | ||
| 2606 | pushFollow(FOLLOW_2); | 3772 | pushFollow(FOLLOW_2); |
| 2607 | this_AllObjects_2=ruleAllObjects(); | 3773 | lv_body_3_0=ruleAggregationExpression(); |
| 2608 | 3774 | ||
| 2609 | state._fsp--; | 3775 | state._fsp--; |
| 2610 | 3776 | ||
| 2611 | 3777 | ||
| 2612 | current = this_AllObjects_2; | 3778 | if (current==null) { |
| 2613 | afterParserOrEnumRuleCall(); | 3779 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); |
| 2614 | 3780 | } | |
| 3781 | set( | ||
| 3782 | current, | ||
| 3783 | "body", | ||
| 3784 | lv_body_3_0, | ||
| 3785 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); | ||
| 3786 | afterParserOrEnumRuleCall(); | ||
| 3787 | |||
| 3788 | |||
| 3789 | } | ||
| 3790 | |||
| 3791 | |||
| 3792 | } | ||
| 3793 | |||
| 3794 | |||
| 3795 | } | ||
| 3796 | |||
| 2615 | 3797 | ||
| 2616 | } | 3798 | } |
| 2617 | break; | 3799 | break; |
| @@ -2634,28 +3816,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2634 | } | 3816 | } |
| 2635 | return current; | 3817 | return current; |
| 2636 | } | 3818 | } |
| 2637 | // $ANTLR end "ruleComplexObject" | 3819 | // $ANTLR end "ruleUnaryExpression" |
| 2638 | 3820 | ||
| 2639 | 3821 | ||
| 2640 | // $ANTLR start "entryRuleObject" | 3822 | // $ANTLR start "entryRuleAggregationExpression" |
| 2641 | // InternalSolverLanguage.g:891:1: entryRuleObject returns [EObject current=null] : iv_ruleObject= ruleObject EOF ; | 3823 | // InternalSolverLanguageParser.g:1519:1: entryRuleAggregationExpression returns [EObject current=null] : iv_ruleAggregationExpression= ruleAggregationExpression EOF ; |
| 2642 | public final EObject entryRuleObject() throws RecognitionException { | 3824 | public final EObject entryRuleAggregationExpression() throws RecognitionException { |
| 2643 | EObject current = null; | 3825 | EObject current = null; |
| 2644 | 3826 | ||
| 2645 | EObject iv_ruleObject = null; | 3827 | EObject iv_ruleAggregationExpression = null; |
| 2646 | 3828 | ||
| 2647 | 3829 | ||
| 2648 | try { | 3830 | try { |
| 2649 | // InternalSolverLanguage.g:891:47: (iv_ruleObject= ruleObject EOF ) | 3831 | // InternalSolverLanguageParser.g:1519:62: (iv_ruleAggregationExpression= ruleAggregationExpression EOF ) |
| 2650 | // InternalSolverLanguage.g:892:2: iv_ruleObject= ruleObject EOF | 3832 | // InternalSolverLanguageParser.g:1520:2: iv_ruleAggregationExpression= ruleAggregationExpression EOF |
| 2651 | { | 3833 | { |
| 2652 | newCompositeNode(grammarAccess.getObjectRule()); | 3834 | newCompositeNode(grammarAccess.getAggregationExpressionRule()); |
| 2653 | pushFollow(FOLLOW_1); | 3835 | pushFollow(FOLLOW_1); |
| 2654 | iv_ruleObject=ruleObject(); | 3836 | iv_ruleAggregationExpression=ruleAggregationExpression(); |
| 2655 | 3837 | ||
| 2656 | state._fsp--; | 3838 | state._fsp--; |
| 2657 | 3839 | ||
| 2658 | current =iv_ruleObject; | 3840 | current =iv_ruleAggregationExpression; |
| 2659 | match(input,EOF,FOLLOW_2); | 3841 | match(input,EOF,FOLLOW_2); |
| 2660 | 3842 | ||
| 2661 | } | 3843 | } |
| @@ -2670,107 +3852,119 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2670 | } | 3852 | } |
| 2671 | return current; | 3853 | return current; |
| 2672 | } | 3854 | } |
| 2673 | // $ANTLR end "entryRuleObject" | 3855 | // $ANTLR end "entryRuleAggregationExpression" |
| 2674 | 3856 | ||
| 2675 | 3857 | ||
| 2676 | // $ANTLR start "ruleObject" | 3858 | // $ANTLR start "ruleAggregationExpression" |
| 2677 | // InternalSolverLanguage.g:898:1: ruleObject returns [EObject current=null] : (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ; | 3859 | // InternalSolverLanguageParser.g:1526:1: ruleAggregationExpression returns [EObject current=null] : (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ; |
| 2678 | public final EObject ruleObject() throws RecognitionException { | 3860 | public final EObject ruleAggregationExpression() throws RecognitionException { |
| 2679 | EObject current = null; | 3861 | EObject current = null; |
| 2680 | 3862 | ||
| 2681 | EObject this_NamedObject_0 = null; | 3863 | EObject this_AtomicExpression_0 = null; |
| 2682 | 3864 | ||
| 2683 | EObject this_UnnamedObject_1 = null; | 3865 | EObject this_Count_1 = null; |
| 2684 | 3866 | ||
| 2685 | EObject this_DataObject_2 = null; | 3867 | EObject this_Aggregation_2 = null; |
| 2686 | 3868 | ||
| 2687 | 3869 | ||
| 2688 | 3870 | ||
| 2689 | enterRule(); | 3871 | enterRule(); |
| 2690 | 3872 | ||
| 2691 | try { | 3873 | try { |
| 2692 | // InternalSolverLanguage.g:904:2: ( (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ) | 3874 | // InternalSolverLanguageParser.g:1532:2: ( (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ) |
| 2693 | // InternalSolverLanguage.g:905:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) | 3875 | // InternalSolverLanguageParser.g:1533:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
| 2694 | { | 3876 | { |
| 2695 | // InternalSolverLanguage.g:905:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) | 3877 | // InternalSolverLanguageParser.g:1533:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
| 2696 | int alt15=3; | 3878 | int alt19=3; |
| 2697 | switch ( input.LA(1) ) { | 3879 | switch ( input.LA(1) ) { |
| 2698 | case 27: | 3880 | case Unknown: |
| 3881 | case Empty: | ||
| 3882 | case Error: | ||
| 3883 | case False: | ||
| 3884 | case True: | ||
| 3885 | case Inf: | ||
| 3886 | case LeftParenthesis: | ||
| 3887 | case LeftSquareBracket: | ||
| 3888 | case RULE_STRING: | ||
| 3889 | case RULE_QUOTED_ID: | ||
| 3890 | case RULE_ID: | ||
| 3891 | case RULE_INT: | ||
| 2699 | { | 3892 | { |
| 2700 | alt15=1; | 3893 | alt19=1; |
| 2701 | } | 3894 | } |
| 2702 | break; | 3895 | break; |
| 2703 | case RULE_ID: | 3896 | case Count: |
| 2704 | { | 3897 | { |
| 2705 | alt15=2; | 3898 | alt19=2; |
| 2706 | } | 3899 | } |
| 2707 | break; | 3900 | break; |
| 2708 | case RULE_INT: | 3901 | case Only: |
| 2709 | case RULE_STRING: | 3902 | case Prod: |
| 2710 | case 11: | 3903 | case Avg: |
| 2711 | case 13: | 3904 | case Max: |
| 2712 | case 14: | 3905 | case Min: |
| 3906 | case Sum: | ||
| 2713 | { | 3907 | { |
| 2714 | alt15=3; | 3908 | alt19=3; |
| 2715 | } | 3909 | } |
| 2716 | break; | 3910 | break; |
| 2717 | default: | 3911 | default: |
| 2718 | NoViableAltException nvae = | 3912 | NoViableAltException nvae = |
| 2719 | new NoViableAltException("", 15, 0, input); | 3913 | new NoViableAltException("", 19, 0, input); |
| 2720 | 3914 | ||
| 2721 | throw nvae; | 3915 | throw nvae; |
| 2722 | } | 3916 | } |
| 2723 | 3917 | ||
| 2724 | switch (alt15) { | 3918 | switch (alt19) { |
| 2725 | case 1 : | 3919 | case 1 : |
| 2726 | // InternalSolverLanguage.g:906:3: this_NamedObject_0= ruleNamedObject | 3920 | // InternalSolverLanguageParser.g:1534:3: this_AtomicExpression_0= ruleAtomicExpression |
| 2727 | { | 3921 | { |
| 2728 | 3922 | ||
| 2729 | newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); | 3923 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
| 2730 | 3924 | ||
| 2731 | pushFollow(FOLLOW_2); | 3925 | pushFollow(FOLLOW_2); |
| 2732 | this_NamedObject_0=ruleNamedObject(); | 3926 | this_AtomicExpression_0=ruleAtomicExpression(); |
| 2733 | 3927 | ||
| 2734 | state._fsp--; | 3928 | state._fsp--; |
| 2735 | 3929 | ||
| 2736 | 3930 | ||
| 2737 | current = this_NamedObject_0; | 3931 | current = this_AtomicExpression_0; |
| 2738 | afterParserOrEnumRuleCall(); | 3932 | afterParserOrEnumRuleCall(); |
| 2739 | 3933 | ||
| 2740 | 3934 | ||
| 2741 | } | 3935 | } |
| 2742 | break; | 3936 | break; |
| 2743 | case 2 : | 3937 | case 2 : |
| 2744 | // InternalSolverLanguage.g:915:3: this_UnnamedObject_1= ruleUnnamedObject | 3938 | // InternalSolverLanguageParser.g:1543:3: this_Count_1= ruleCount |
| 2745 | { | 3939 | { |
| 2746 | 3940 | ||
| 2747 | newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); | 3941 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
| 2748 | 3942 | ||
| 2749 | pushFollow(FOLLOW_2); | 3943 | pushFollow(FOLLOW_2); |
| 2750 | this_UnnamedObject_1=ruleUnnamedObject(); | 3944 | this_Count_1=ruleCount(); |
| 2751 | 3945 | ||
| 2752 | state._fsp--; | 3946 | state._fsp--; |
| 2753 | 3947 | ||
| 2754 | 3948 | ||
| 2755 | current = this_UnnamedObject_1; | 3949 | current = this_Count_1; |
| 2756 | afterParserOrEnumRuleCall(); | 3950 | afterParserOrEnumRuleCall(); |
| 2757 | 3951 | ||
| 2758 | 3952 | ||
| 2759 | } | 3953 | } |
| 2760 | break; | 3954 | break; |
| 2761 | case 3 : | 3955 | case 3 : |
| 2762 | // InternalSolverLanguage.g:924:3: this_DataObject_2= ruleDataObject | 3956 | // InternalSolverLanguageParser.g:1552:3: this_Aggregation_2= ruleAggregation |
| 2763 | { | 3957 | { |
| 2764 | 3958 | ||
| 2765 | newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); | 3959 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
| 2766 | 3960 | ||
| 2767 | pushFollow(FOLLOW_2); | 3961 | pushFollow(FOLLOW_2); |
| 2768 | this_DataObject_2=ruleDataObject(); | 3962 | this_Aggregation_2=ruleAggregation(); |
| 2769 | 3963 | ||
| 2770 | state._fsp--; | 3964 | state._fsp--; |
| 2771 | 3965 | ||
| 2772 | 3966 | ||
| 2773 | current = this_DataObject_2; | 3967 | current = this_Aggregation_2; |
| 2774 | afterParserOrEnumRuleCall(); | 3968 | afterParserOrEnumRuleCall(); |
| 2775 | 3969 | ||
| 2776 | 3970 | ||
| @@ -2795,28 +3989,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2795 | } | 3989 | } |
| 2796 | return current; | 3990 | return current; |
| 2797 | } | 3991 | } |
| 2798 | // $ANTLR end "ruleObject" | 3992 | // $ANTLR end "ruleAggregationExpression" |
| 2799 | 3993 | ||
| 2800 | 3994 | ||
| 2801 | // $ANTLR start "entryRuleNamedObject" | 3995 | // $ANTLR start "entryRuleCount" |
| 2802 | // InternalSolverLanguage.g:936:1: entryRuleNamedObject returns [EObject current=null] : iv_ruleNamedObject= ruleNamedObject EOF ; | 3996 | // InternalSolverLanguageParser.g:1564:1: entryRuleCount returns [EObject current=null] : iv_ruleCount= ruleCount EOF ; |
| 2803 | public final EObject entryRuleNamedObject() throws RecognitionException { | 3997 | public final EObject entryRuleCount() throws RecognitionException { |
| 2804 | EObject current = null; | 3998 | EObject current = null; |
| 2805 | 3999 | ||
| 2806 | EObject iv_ruleNamedObject = null; | 4000 | EObject iv_ruleCount = null; |
| 2807 | 4001 | ||
| 2808 | 4002 | ||
| 2809 | try { | 4003 | try { |
| 2810 | // InternalSolverLanguage.g:936:52: (iv_ruleNamedObject= ruleNamedObject EOF ) | 4004 | // InternalSolverLanguageParser.g:1564:46: (iv_ruleCount= ruleCount EOF ) |
| 2811 | // InternalSolverLanguage.g:937:2: iv_ruleNamedObject= ruleNamedObject EOF | 4005 | // InternalSolverLanguageParser.g:1565:2: iv_ruleCount= ruleCount EOF |
| 2812 | { | 4006 | { |
| 2813 | newCompositeNode(grammarAccess.getNamedObjectRule()); | 4007 | newCompositeNode(grammarAccess.getCountRule()); |
| 2814 | pushFollow(FOLLOW_1); | 4008 | pushFollow(FOLLOW_1); |
| 2815 | iv_ruleNamedObject=ruleNamedObject(); | 4009 | iv_ruleCount=ruleCount(); |
| 2816 | 4010 | ||
| 2817 | state._fsp--; | 4011 | state._fsp--; |
| 2818 | 4012 | ||
| 2819 | current =iv_ruleNamedObject; | 4013 | current =iv_ruleCount; |
| 2820 | match(input,EOF,FOLLOW_2); | 4014 | match(input,EOF,FOLLOW_2); |
| 2821 | 4015 | ||
| 2822 | } | 4016 | } |
| @@ -2831,51 +4025,62 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2831 | } | 4025 | } |
| 2832 | return current; | 4026 | return current; |
| 2833 | } | 4027 | } |
| 2834 | // $ANTLR end "entryRuleNamedObject" | 4028 | // $ANTLR end "entryRuleCount" |
| 2835 | 4029 | ||
| 2836 | 4030 | ||
| 2837 | // $ANTLR start "ruleNamedObject" | 4031 | // $ANTLR start "ruleCount" |
| 2838 | // InternalSolverLanguage.g:943:1: ruleNamedObject returns [EObject current=null] : (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ; | 4032 | // InternalSolverLanguageParser.g:1571:1: ruleCount returns [EObject current=null] : (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ; |
| 2839 | public final EObject ruleNamedObject() throws RecognitionException { | 4033 | public final EObject ruleCount() throws RecognitionException { |
| 2840 | EObject current = null; | 4034 | EObject current = null; |
| 2841 | 4035 | ||
| 2842 | Token otherlv_0=null; | 4036 | Token otherlv_0=null; |
| 2843 | Token lv_name_1_0=null; | 4037 | Token otherlv_1=null; |
| 2844 | Token otherlv_2=null; | 4038 | Token otherlv_3=null; |
| 4039 | EObject lv_body_2_0 = null; | ||
| 4040 | |||
| 2845 | 4041 | ||
| 2846 | 4042 | ||
| 2847 | enterRule(); | 4043 | enterRule(); |
| 2848 | 4044 | ||
| 2849 | try { | 4045 | try { |
| 2850 | // InternalSolverLanguage.g:949:2: ( (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ) | 4046 | // InternalSolverLanguageParser.g:1577:2: ( (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ) |
| 2851 | // InternalSolverLanguage.g:950:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) | 4047 | // InternalSolverLanguageParser.g:1578:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) |
| 2852 | { | 4048 | { |
| 2853 | // InternalSolverLanguage.g:950:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) | 4049 | // InternalSolverLanguageParser.g:1578:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) |
| 2854 | // InternalSolverLanguage.g:951:3: otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' | 4050 | // InternalSolverLanguageParser.g:1579:3: otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket |
| 2855 | { | 4051 | { |
| 2856 | otherlv_0=(Token)match(input,27,FOLLOW_12); | 4052 | otherlv_0=(Token)match(input,Count,FOLLOW_26); |
| 4053 | |||
| 4054 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | ||
| 4055 | |||
| 4056 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_6); | ||
| 2857 | 4057 | ||
| 2858 | newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); | 4058 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
| 2859 | 4059 | ||
| 2860 | // InternalSolverLanguage.g:955:3: ( (lv_name_1_0= RULE_ID ) ) | 4060 | // InternalSolverLanguageParser.g:1587:3: ( (lv_body_2_0= ruleExpression ) ) |
| 2861 | // InternalSolverLanguage.g:956:4: (lv_name_1_0= RULE_ID ) | 4061 | // InternalSolverLanguageParser.g:1588:4: (lv_body_2_0= ruleExpression ) |
| 2862 | { | 4062 | { |
| 2863 | // InternalSolverLanguage.g:956:4: (lv_name_1_0= RULE_ID ) | 4063 | // InternalSolverLanguageParser.g:1588:4: (lv_body_2_0= ruleExpression ) |
| 2864 | // InternalSolverLanguage.g:957:5: lv_name_1_0= RULE_ID | 4064 | // InternalSolverLanguageParser.g:1589:5: lv_body_2_0= ruleExpression |
| 2865 | { | 4065 | { |
| 2866 | lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_13); | ||
| 2867 | 4066 | ||
| 2868 | newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); | 4067 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); |
| 2869 | 4068 | ||
| 4069 | pushFollow(FOLLOW_27); | ||
| 4070 | lv_body_2_0=ruleExpression(); | ||
| 4071 | |||
| 4072 | state._fsp--; | ||
| 4073 | |||
| 2870 | 4074 | ||
| 2871 | if (current==null) { | 4075 | if (current==null) { |
| 2872 | current = createModelElement(grammarAccess.getNamedObjectRule()); | 4076 | current = createModelElementForParent(grammarAccess.getCountRule()); |
| 2873 | } | 4077 | } |
| 2874 | setWithLastConsumed( | 4078 | set( |
| 2875 | current, | 4079 | current, |
| 2876 | "name", | 4080 | "body", |
| 2877 | lv_name_1_0, | 4081 | lv_body_2_0, |
| 2878 | "org.eclipse.xtext.common.Terminals.ID"); | 4082 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
| 4083 | afterParserOrEnumRuleCall(); | ||
| 2879 | 4084 | ||
| 2880 | 4085 | ||
| 2881 | } | 4086 | } |
| @@ -2883,9 +4088,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2883 | 4088 | ||
| 2884 | } | 4089 | } |
| 2885 | 4090 | ||
| 2886 | otherlv_2=(Token)match(input,27,FOLLOW_2); | 4091 | otherlv_3=(Token)match(input,RightCurlyBracket,FOLLOW_2); |
| 2887 | 4092 | ||
| 2888 | newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); | 4093 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
| 2889 | 4094 | ||
| 2890 | 4095 | ||
| 2891 | } | 4096 | } |
| @@ -2906,28 +4111,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2906 | } | 4111 | } |
| 2907 | return current; | 4112 | return current; |
| 2908 | } | 4113 | } |
| 2909 | // $ANTLR end "ruleNamedObject" | 4114 | // $ANTLR end "ruleCount" |
| 2910 | 4115 | ||
| 2911 | 4116 | ||
| 2912 | // $ANTLR start "entryRuleUnnamedObject" | 4117 | // $ANTLR start "entryRuleAggregation" |
| 2913 | // InternalSolverLanguage.g:981:1: entryRuleUnnamedObject returns [EObject current=null] : iv_ruleUnnamedObject= ruleUnnamedObject EOF ; | 4118 | // InternalSolverLanguageParser.g:1614:1: entryRuleAggregation returns [EObject current=null] : iv_ruleAggregation= ruleAggregation EOF ; |
| 2914 | public final EObject entryRuleUnnamedObject() throws RecognitionException { | 4119 | public final EObject entryRuleAggregation() throws RecognitionException { |
| 2915 | EObject current = null; | 4120 | EObject current = null; |
| 2916 | 4121 | ||
| 2917 | EObject iv_ruleUnnamedObject = null; | 4122 | EObject iv_ruleAggregation = null; |
| 2918 | 4123 | ||
| 2919 | 4124 | ||
| 2920 | try { | 4125 | try { |
| 2921 | // InternalSolverLanguage.g:981:54: (iv_ruleUnnamedObject= ruleUnnamedObject EOF ) | 4126 | // InternalSolverLanguageParser.g:1614:52: (iv_ruleAggregation= ruleAggregation EOF ) |
| 2922 | // InternalSolverLanguage.g:982:2: iv_ruleUnnamedObject= ruleUnnamedObject EOF | 4127 | // InternalSolverLanguageParser.g:1615:2: iv_ruleAggregation= ruleAggregation EOF |
| 2923 | { | 4128 | { |
| 2924 | newCompositeNode(grammarAccess.getUnnamedObjectRule()); | 4129 | newCompositeNode(grammarAccess.getAggregationRule()); |
| 2925 | pushFollow(FOLLOW_1); | 4130 | pushFollow(FOLLOW_1); |
| 2926 | iv_ruleUnnamedObject=ruleUnnamedObject(); | 4131 | iv_ruleAggregation=ruleAggregation(); |
| 2927 | 4132 | ||
| 2928 | state._fsp--; | 4133 | state._fsp--; |
| 2929 | 4134 | ||
| 2930 | current =iv_ruleUnnamedObject; | 4135 | current =iv_ruleAggregation; |
| 2931 | match(input,EOF,FOLLOW_2); | 4136 | match(input,EOF,FOLLOW_2); |
| 2932 | 4137 | ||
| 2933 | } | 4138 | } |
| @@ -2942,46 +4147,139 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 2942 | } | 4147 | } |
| 2943 | return current; | 4148 | return current; |
| 2944 | } | 4149 | } |
| 2945 | // $ANTLR end "entryRuleUnnamedObject" | 4150 | // $ANTLR end "entryRuleAggregation" |
| 2946 | 4151 | ||
| 2947 | 4152 | ||
| 2948 | // $ANTLR start "ruleUnnamedObject" | 4153 | // $ANTLR start "ruleAggregation" |
| 2949 | // InternalSolverLanguage.g:988:1: ruleUnnamedObject returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 4154 | // InternalSolverLanguageParser.g:1621:1: ruleAggregation returns [EObject current=null] : ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ; |
| 2950 | public final EObject ruleUnnamedObject() throws RecognitionException { | 4155 | public final EObject ruleAggregation() throws RecognitionException { |
| 2951 | EObject current = null; | 4156 | EObject current = null; |
| 2952 | 4157 | ||
| 2953 | Token lv_name_0_0=null; | 4158 | Token otherlv_1=null; |
| 4159 | Token otherlv_3=null; | ||
| 4160 | Token otherlv_5=null; | ||
| 4161 | Enumerator lv_op_0_0 = null; | ||
| 4162 | |||
| 4163 | EObject lv_body_2_0 = null; | ||
| 4164 | |||
| 4165 | EObject lv_condition_4_0 = null; | ||
| 4166 | |||
| 2954 | 4167 | ||
| 2955 | 4168 | ||
| 2956 | enterRule(); | 4169 | enterRule(); |
| 2957 | 4170 | ||
| 2958 | try { | 4171 | try { |
| 2959 | // InternalSolverLanguage.g:994:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 4172 | // InternalSolverLanguageParser.g:1627:2: ( ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ) |
| 2960 | // InternalSolverLanguage.g:995:2: ( (lv_name_0_0= RULE_ID ) ) | 4173 | // InternalSolverLanguageParser.g:1628:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) |
| 2961 | { | 4174 | { |
| 2962 | // InternalSolverLanguage.g:995:2: ( (lv_name_0_0= RULE_ID ) ) | 4175 | // InternalSolverLanguageParser.g:1628:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) |
| 2963 | // InternalSolverLanguage.g:996:3: (lv_name_0_0= RULE_ID ) | 4176 | // InternalSolverLanguageParser.g:1629:3: ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket |
| 2964 | { | 4177 | { |
| 2965 | // InternalSolverLanguage.g:996:3: (lv_name_0_0= RULE_ID ) | 4178 | // InternalSolverLanguageParser.g:1629:3: ( (lv_op_0_0= ruleAggregationOp ) ) |
| 2966 | // InternalSolverLanguage.g:997:4: lv_name_0_0= RULE_ID | 4179 | // InternalSolverLanguageParser.g:1630:4: (lv_op_0_0= ruleAggregationOp ) |
| 4180 | { | ||
| 4181 | // InternalSolverLanguageParser.g:1630:4: (lv_op_0_0= ruleAggregationOp ) | ||
| 4182 | // InternalSolverLanguageParser.g:1631:5: lv_op_0_0= ruleAggregationOp | ||
| 2967 | { | 4183 | { |
| 2968 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
| 2969 | 4184 | ||
| 2970 | newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); | 4185 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); |
| 2971 | 4186 | ||
| 4187 | pushFollow(FOLLOW_26); | ||
| 4188 | lv_op_0_0=ruleAggregationOp(); | ||
| 4189 | |||
| 4190 | state._fsp--; | ||
| 4191 | |||
| 4192 | |||
| 4193 | if (current==null) { | ||
| 4194 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4195 | } | ||
| 4196 | set( | ||
| 4197 | current, | ||
| 4198 | "op", | ||
| 4199 | lv_op_0_0, | ||
| 4200 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); | ||
| 4201 | afterParserOrEnumRuleCall(); | ||
| 4202 | |||
| 4203 | |||
| 4204 | } | ||
| 4205 | |||
| 4206 | |||
| 4207 | } | ||
| 4208 | |||
| 4209 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_6); | ||
| 4210 | |||
| 4211 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
| 4212 | |||
| 4213 | // InternalSolverLanguageParser.g:1652:3: ( (lv_body_2_0= ruleExpression ) ) | ||
| 4214 | // InternalSolverLanguageParser.g:1653:4: (lv_body_2_0= ruleExpression ) | ||
| 4215 | { | ||
| 4216 | // InternalSolverLanguageParser.g:1653:4: (lv_body_2_0= ruleExpression ) | ||
| 4217 | // InternalSolverLanguageParser.g:1654:5: lv_body_2_0= ruleExpression | ||
| 4218 | { | ||
| 4219 | |||
| 4220 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | ||
| 4221 | |||
| 4222 | pushFollow(FOLLOW_28); | ||
| 4223 | lv_body_2_0=ruleExpression(); | ||
| 4224 | |||
| 4225 | state._fsp--; | ||
| 4226 | |||
| 4227 | |||
| 4228 | if (current==null) { | ||
| 4229 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4230 | } | ||
| 4231 | set( | ||
| 4232 | current, | ||
| 4233 | "body", | ||
| 4234 | lv_body_2_0, | ||
| 4235 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 4236 | afterParserOrEnumRuleCall(); | ||
| 4237 | |||
| 4238 | |||
| 4239 | } | ||
| 2972 | 4240 | ||
| 2973 | if (current==null) { | ||
| 2974 | current = createModelElement(grammarAccess.getUnnamedObjectRule()); | ||
| 2975 | } | ||
| 2976 | setWithLastConsumed( | ||
| 2977 | current, | ||
| 2978 | "name", | ||
| 2979 | lv_name_0_0, | ||
| 2980 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 2981 | |||
| 2982 | 4241 | ||
| 2983 | } | 4242 | } |
| 2984 | 4243 | ||
| 4244 | otherlv_3=(Token)match(input,VerticalLine,FOLLOW_6); | ||
| 4245 | |||
| 4246 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
| 4247 | |||
| 4248 | // InternalSolverLanguageParser.g:1675:3: ( (lv_condition_4_0= ruleExpression ) ) | ||
| 4249 | // InternalSolverLanguageParser.g:1676:4: (lv_condition_4_0= ruleExpression ) | ||
| 4250 | { | ||
| 4251 | // InternalSolverLanguageParser.g:1676:4: (lv_condition_4_0= ruleExpression ) | ||
| 4252 | // InternalSolverLanguageParser.g:1677:5: lv_condition_4_0= ruleExpression | ||
| 4253 | { | ||
| 4254 | |||
| 4255 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
| 4256 | |||
| 4257 | pushFollow(FOLLOW_27); | ||
| 4258 | lv_condition_4_0=ruleExpression(); | ||
| 4259 | |||
| 4260 | state._fsp--; | ||
| 4261 | |||
| 4262 | |||
| 4263 | if (current==null) { | ||
| 4264 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
| 4265 | } | ||
| 4266 | set( | ||
| 4267 | current, | ||
| 4268 | "condition", | ||
| 4269 | lv_condition_4_0, | ||
| 4270 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 4271 | afterParserOrEnumRuleCall(); | ||
| 4272 | |||
| 4273 | |||
| 4274 | } | ||
| 4275 | |||
| 4276 | |||
| 4277 | } | ||
| 4278 | |||
| 4279 | otherlv_5=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
| 4280 | |||
| 4281 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
| 4282 | |||
| 2985 | 4283 | ||
| 2986 | } | 4284 | } |
| 2987 | 4285 | ||
| @@ -3001,28 +4299,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3001 | } | 4299 | } |
| 3002 | return current; | 4300 | return current; |
| 3003 | } | 4301 | } |
| 3004 | // $ANTLR end "ruleUnnamedObject" | 4302 | // $ANTLR end "ruleAggregation" |
| 3005 | 4303 | ||
| 3006 | 4304 | ||
| 3007 | // $ANTLR start "entryRuleDataObject" | 4305 | // $ANTLR start "entryRuleAtomicExpression" |
| 3008 | // InternalSolverLanguage.g:1016:1: entryRuleDataObject returns [EObject current=null] : iv_ruleDataObject= ruleDataObject EOF ; | 4306 | // InternalSolverLanguageParser.g:1702:1: entryRuleAtomicExpression returns [EObject current=null] : iv_ruleAtomicExpression= ruleAtomicExpression EOF ; |
| 3009 | public final EObject entryRuleDataObject() throws RecognitionException { | 4307 | public final EObject entryRuleAtomicExpression() throws RecognitionException { |
| 3010 | EObject current = null; | 4308 | EObject current = null; |
| 3011 | 4309 | ||
| 3012 | EObject iv_ruleDataObject = null; | 4310 | EObject iv_ruleAtomicExpression = null; |
| 3013 | 4311 | ||
| 3014 | 4312 | ||
| 3015 | try { | 4313 | try { |
| 3016 | // InternalSolverLanguage.g:1016:51: (iv_ruleDataObject= ruleDataObject EOF ) | 4314 | // InternalSolverLanguageParser.g:1702:57: (iv_ruleAtomicExpression= ruleAtomicExpression EOF ) |
| 3017 | // InternalSolverLanguage.g:1017:2: iv_ruleDataObject= ruleDataObject EOF | 4315 | // InternalSolverLanguageParser.g:1703:2: iv_ruleAtomicExpression= ruleAtomicExpression EOF |
| 3018 | { | 4316 | { |
| 3019 | newCompositeNode(grammarAccess.getDataObjectRule()); | 4317 | newCompositeNode(grammarAccess.getAtomicExpressionRule()); |
| 3020 | pushFollow(FOLLOW_1); | 4318 | pushFollow(FOLLOW_1); |
| 3021 | iv_ruleDataObject=ruleDataObject(); | 4319 | iv_ruleAtomicExpression=ruleAtomicExpression(); |
| 3022 | 4320 | ||
| 3023 | state._fsp--; | 4321 | state._fsp--; |
| 3024 | 4322 | ||
| 3025 | current =iv_ruleDataObject; | 4323 | current =iv_ruleAtomicExpression; |
| 3026 | match(input,EOF,FOLLOW_2); | 4324 | match(input,EOF,FOLLOW_2); |
| 3027 | 4325 | ||
| 3028 | } | 4326 | } |
| @@ -3037,170 +4335,142 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3037 | } | 4335 | } |
| 3038 | return current; | 4336 | return current; |
| 3039 | } | 4337 | } |
| 3040 | // $ANTLR end "entryRuleDataObject" | 4338 | // $ANTLR end "entryRuleAtomicExpression" |
| 3041 | 4339 | ||
| 3042 | 4340 | ||
| 3043 | // $ANTLR start "ruleDataObject" | 4341 | // $ANTLR start "ruleAtomicExpression" |
| 3044 | // InternalSolverLanguage.g:1023:1: ruleDataObject returns [EObject current=null] : (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ; | 4342 | // InternalSolverLanguageParser.g:1709:1: ruleAtomicExpression returns [EObject current=null] : (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ; |
| 3045 | public final EObject ruleDataObject() throws RecognitionException { | 4343 | public final EObject ruleAtomicExpression() throws RecognitionException { |
| 3046 | EObject current = null; | 4344 | EObject current = null; |
| 3047 | 4345 | ||
| 3048 | EObject this_BooleanObject_0 = null; | 4346 | Token otherlv_4=null; |
| 4347 | Token otherlv_6=null; | ||
| 4348 | EObject this_Reference_0 = null; | ||
| 4349 | |||
| 4350 | EObject this_Call_1 = null; | ||
| 3049 | 4351 | ||
| 3050 | EObject this_IntObject_1 = null; | 4352 | EObject this_Interval_2 = null; |
| 3051 | 4353 | ||
| 3052 | EObject this_RealObject_2 = null; | 4354 | EObject this_Literal_3 = null; |
| 3053 | 4355 | ||
| 3054 | EObject this_StringObject_3 = null; | 4356 | EObject this_Expression_5 = null; |
| 3055 | 4357 | ||
| 3056 | 4358 | ||
| 3057 | 4359 | ||
| 3058 | enterRule(); | 4360 | enterRule(); |
| 3059 | 4361 | ||
| 3060 | try { | 4362 | try { |
| 3061 | // InternalSolverLanguage.g:1029:2: ( (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ) | 4363 | // InternalSolverLanguageParser.g:1715:2: ( (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ) |
| 3062 | // InternalSolverLanguage.g:1030:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) | 4364 | // InternalSolverLanguageParser.g:1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) |
| 3063 | { | 4365 | { |
| 3064 | // InternalSolverLanguage.g:1030:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) | 4366 | // InternalSolverLanguageParser.g:1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) |
| 3065 | int alt16=4; | 4367 | int alt20=5; |
| 3066 | switch ( input.LA(1) ) { | 4368 | alt20 = dfa20.predict(input); |
| 3067 | case 13: | 4369 | switch (alt20) { |
| 3068 | case 14: | ||
| 3069 | { | ||
| 3070 | alt16=1; | ||
| 3071 | } | ||
| 3072 | break; | ||
| 3073 | case 11: | ||
| 3074 | { | ||
| 3075 | int LA16_2 = input.LA(2); | ||
| 3076 | |||
| 3077 | if ( (LA16_2==RULE_INT) ) { | ||
| 3078 | int LA16_3 = input.LA(3); | ||
| 3079 | |||
| 3080 | if ( (LA16_3==12) ) { | ||
| 3081 | alt16=3; | ||
| 3082 | } | ||
| 3083 | else if ( (LA16_3==EOF||(LA16_3>=18 && LA16_3<=19)) ) { | ||
| 3084 | alt16=2; | ||
| 3085 | } | ||
| 3086 | else { | ||
| 3087 | NoViableAltException nvae = | ||
| 3088 | new NoViableAltException("", 16, 3, input); | ||
| 3089 | |||
| 3090 | throw nvae; | ||
| 3091 | } | ||
| 3092 | } | ||
| 3093 | else { | ||
| 3094 | NoViableAltException nvae = | ||
| 3095 | new NoViableAltException("", 16, 2, input); | ||
| 3096 | |||
| 3097 | throw nvae; | ||
| 3098 | } | ||
| 3099 | } | ||
| 3100 | break; | ||
| 3101 | case RULE_INT: | ||
| 3102 | { | ||
| 3103 | int LA16_3 = input.LA(2); | ||
| 3104 | |||
| 3105 | if ( (LA16_3==12) ) { | ||
| 3106 | alt16=3; | ||
| 3107 | } | ||
| 3108 | else if ( (LA16_3==EOF||(LA16_3>=18 && LA16_3<=19)) ) { | ||
| 3109 | alt16=2; | ||
| 3110 | } | ||
| 3111 | else { | ||
| 3112 | NoViableAltException nvae = | ||
| 3113 | new NoViableAltException("", 16, 3, input); | ||
| 3114 | |||
| 3115 | throw nvae; | ||
| 3116 | } | ||
| 3117 | } | ||
| 3118 | break; | ||
| 3119 | case RULE_STRING: | ||
| 3120 | { | ||
| 3121 | alt16=4; | ||
| 3122 | } | ||
| 3123 | break; | ||
| 3124 | default: | ||
| 3125 | NoViableAltException nvae = | ||
| 3126 | new NoViableAltException("", 16, 0, input); | ||
| 3127 | |||
| 3128 | throw nvae; | ||
| 3129 | } | ||
| 3130 | |||
| 3131 | switch (alt16) { | ||
| 3132 | case 1 : | 4370 | case 1 : |
| 3133 | // InternalSolverLanguage.g:1031:3: this_BooleanObject_0= ruleBooleanObject | 4371 | // InternalSolverLanguageParser.g:1717:3: this_Reference_0= ruleReference |
| 3134 | { | 4372 | { |
| 3135 | 4373 | ||
| 3136 | newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); | 4374 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); |
| 3137 | 4375 | ||
| 3138 | pushFollow(FOLLOW_2); | 4376 | pushFollow(FOLLOW_2); |
| 3139 | this_BooleanObject_0=ruleBooleanObject(); | 4377 | this_Reference_0=ruleReference(); |
| 3140 | 4378 | ||
| 3141 | state._fsp--; | 4379 | state._fsp--; |
| 3142 | 4380 | ||
| 3143 | 4381 | ||
| 3144 | current = this_BooleanObject_0; | 4382 | current = this_Reference_0; |
| 3145 | afterParserOrEnumRuleCall(); | 4383 | afterParserOrEnumRuleCall(); |
| 3146 | 4384 | ||
| 3147 | 4385 | ||
| 3148 | } | 4386 | } |
| 3149 | break; | 4387 | break; |
| 3150 | case 2 : | 4388 | case 2 : |
| 3151 | // InternalSolverLanguage.g:1040:3: this_IntObject_1= ruleIntObject | 4389 | // InternalSolverLanguageParser.g:1726:3: this_Call_1= ruleCall |
| 3152 | { | 4390 | { |
| 3153 | 4391 | ||
| 3154 | newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); | 4392 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); |
| 3155 | 4393 | ||
| 3156 | pushFollow(FOLLOW_2); | 4394 | pushFollow(FOLLOW_2); |
| 3157 | this_IntObject_1=ruleIntObject(); | 4395 | this_Call_1=ruleCall(); |
| 3158 | 4396 | ||
| 3159 | state._fsp--; | 4397 | state._fsp--; |
| 3160 | 4398 | ||
| 3161 | 4399 | ||
| 3162 | current = this_IntObject_1; | 4400 | current = this_Call_1; |
| 3163 | afterParserOrEnumRuleCall(); | 4401 | afterParserOrEnumRuleCall(); |
| 3164 | 4402 | ||
| 3165 | 4403 | ||
| 3166 | } | 4404 | } |
| 3167 | break; | 4405 | break; |
| 3168 | case 3 : | 4406 | case 3 : |
| 3169 | // InternalSolverLanguage.g:1049:3: this_RealObject_2= ruleRealObject | 4407 | // InternalSolverLanguageParser.g:1735:3: this_Interval_2= ruleInterval |
| 3170 | { | 4408 | { |
| 3171 | 4409 | ||
| 3172 | newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); | 4410 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); |
| 3173 | 4411 | ||
| 3174 | pushFollow(FOLLOW_2); | 4412 | pushFollow(FOLLOW_2); |
| 3175 | this_RealObject_2=ruleRealObject(); | 4413 | this_Interval_2=ruleInterval(); |
| 3176 | 4414 | ||
| 3177 | state._fsp--; | 4415 | state._fsp--; |
| 3178 | 4416 | ||
| 3179 | 4417 | ||
| 3180 | current = this_RealObject_2; | 4418 | current = this_Interval_2; |
| 3181 | afterParserOrEnumRuleCall(); | 4419 | afterParserOrEnumRuleCall(); |
| 3182 | 4420 | ||
| 3183 | 4421 | ||
| 3184 | } | 4422 | } |
| 3185 | break; | 4423 | break; |
| 3186 | case 4 : | 4424 | case 4 : |
| 3187 | // InternalSolverLanguage.g:1058:3: this_StringObject_3= ruleStringObject | 4425 | // InternalSolverLanguageParser.g:1744:3: this_Literal_3= ruleLiteral |
| 3188 | { | 4426 | { |
| 3189 | 4427 | ||
| 3190 | newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); | 4428 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); |
| 3191 | 4429 | ||
| 3192 | pushFollow(FOLLOW_2); | 4430 | pushFollow(FOLLOW_2); |
| 3193 | this_StringObject_3=ruleStringObject(); | 4431 | this_Literal_3=ruleLiteral(); |
| 3194 | 4432 | ||
| 3195 | state._fsp--; | 4433 | state._fsp--; |
| 3196 | 4434 | ||
| 3197 | 4435 | ||
| 3198 | current = this_StringObject_3; | 4436 | current = this_Literal_3; |
| 3199 | afterParserOrEnumRuleCall(); | 4437 | afterParserOrEnumRuleCall(); |
| 3200 | 4438 | ||
| 3201 | 4439 | ||
| 3202 | } | 4440 | } |
| 3203 | break; | 4441 | break; |
| 4442 | case 5 : | ||
| 4443 | // InternalSolverLanguageParser.g:1753:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) | ||
| 4444 | { | ||
| 4445 | // InternalSolverLanguageParser.g:1753:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) | ||
| 4446 | // InternalSolverLanguageParser.g:1754:4: otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis | ||
| 4447 | { | ||
| 4448 | otherlv_4=(Token)match(input,LeftParenthesis,FOLLOW_6); | ||
| 4449 | |||
| 4450 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
| 4451 | |||
| 4452 | |||
| 4453 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); | ||
| 4454 | |||
| 4455 | pushFollow(FOLLOW_29); | ||
| 4456 | this_Expression_5=ruleExpression(); | ||
| 4457 | |||
| 4458 | state._fsp--; | ||
| 4459 | |||
| 4460 | |||
| 4461 | current = this_Expression_5; | ||
| 4462 | afterParserOrEnumRuleCall(); | ||
| 4463 | |||
| 4464 | otherlv_6=(Token)match(input,RightParenthesis,FOLLOW_2); | ||
| 4465 | |||
| 4466 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); | ||
| 4467 | |||
| 4468 | |||
| 4469 | } | ||
| 4470 | |||
| 4471 | |||
| 4472 | } | ||
| 4473 | break; | ||
| 3204 | 4474 | ||
| 3205 | } | 4475 | } |
| 3206 | 4476 | ||
| @@ -3220,28 +4490,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3220 | } | 4490 | } |
| 3221 | return current; | 4491 | return current; |
| 3222 | } | 4492 | } |
| 3223 | // $ANTLR end "ruleDataObject" | 4493 | // $ANTLR end "ruleAtomicExpression" |
| 3224 | 4494 | ||
| 3225 | 4495 | ||
| 3226 | // $ANTLR start "entryRuleBooleanObject" | 4496 | // $ANTLR start "entryRuleCall" |
| 3227 | // InternalSolverLanguage.g:1070:1: entryRuleBooleanObject returns [EObject current=null] : iv_ruleBooleanObject= ruleBooleanObject EOF ; | 4497 | // InternalSolverLanguageParser.g:1775:1: entryRuleCall returns [EObject current=null] : iv_ruleCall= ruleCall EOF ; |
| 3228 | public final EObject entryRuleBooleanObject() throws RecognitionException { | 4498 | public final EObject entryRuleCall() throws RecognitionException { |
| 3229 | EObject current = null; | 4499 | EObject current = null; |
| 3230 | 4500 | ||
| 3231 | EObject iv_ruleBooleanObject = null; | 4501 | EObject iv_ruleCall = null; |
| 3232 | 4502 | ||
| 3233 | 4503 | ||
| 3234 | try { | 4504 | try { |
| 3235 | // InternalSolverLanguage.g:1070:54: (iv_ruleBooleanObject= ruleBooleanObject EOF ) | 4505 | // InternalSolverLanguageParser.g:1775:45: (iv_ruleCall= ruleCall EOF ) |
| 3236 | // InternalSolverLanguage.g:1071:2: iv_ruleBooleanObject= ruleBooleanObject EOF | 4506 | // InternalSolverLanguageParser.g:1776:2: iv_ruleCall= ruleCall EOF |
| 3237 | { | 4507 | { |
| 3238 | newCompositeNode(grammarAccess.getBooleanObjectRule()); | 4508 | newCompositeNode(grammarAccess.getCallRule()); |
| 3239 | pushFollow(FOLLOW_1); | 4509 | pushFollow(FOLLOW_1); |
| 3240 | iv_ruleBooleanObject=ruleBooleanObject(); | 4510 | iv_ruleCall=ruleCall(); |
| 3241 | 4511 | ||
| 3242 | state._fsp--; | 4512 | state._fsp--; |
| 3243 | 4513 | ||
| 3244 | current =iv_ruleBooleanObject; | 4514 | current =iv_ruleCall; |
| 3245 | match(input,EOF,FOLLOW_2); | 4515 | match(input,EOF,FOLLOW_2); |
| 3246 | 4516 | ||
| 3247 | } | 4517 | } |
| @@ -3256,49 +4526,168 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3256 | } | 4526 | } |
| 3257 | return current; | 4527 | return current; |
| 3258 | } | 4528 | } |
| 3259 | // $ANTLR end "entryRuleBooleanObject" | 4529 | // $ANTLR end "entryRuleCall" |
| 3260 | 4530 | ||
| 3261 | 4531 | ||
| 3262 | // $ANTLR start "ruleBooleanObject" | 4532 | // $ANTLR start "ruleCall" |
| 3263 | // InternalSolverLanguage.g:1077:1: ruleBooleanObject returns [EObject current=null] : ( (lv_value_0_0= ruleBooleanValue ) ) ; | 4533 | // InternalSolverLanguageParser.g:1782:1: ruleCall returns [EObject current=null] : ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ; |
| 3264 | public final EObject ruleBooleanObject() throws RecognitionException { | 4534 | public final EObject ruleCall() throws RecognitionException { |
| 3265 | EObject current = null; | 4535 | EObject current = null; |
| 3266 | 4536 | ||
| 3267 | EObject lv_value_0_0 = null; | 4537 | Token lv_transitiveClosure_1_0=null; |
| 4538 | Token lv_reflexiveTransitiveClosure_2_0=null; | ||
| 4539 | EObject lv_functor_0_0 = null; | ||
| 4540 | |||
| 4541 | EObject lv_argumentList_3_0 = null; | ||
| 3268 | 4542 | ||
| 3269 | 4543 | ||
| 3270 | 4544 | ||
| 3271 | enterRule(); | 4545 | enterRule(); |
| 3272 | 4546 | ||
| 3273 | try { | 4547 | try { |
| 3274 | // InternalSolverLanguage.g:1083:2: ( ( (lv_value_0_0= ruleBooleanValue ) ) ) | 4548 | // InternalSolverLanguageParser.g:1788:2: ( ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ) |
| 3275 | // InternalSolverLanguage.g:1084:2: ( (lv_value_0_0= ruleBooleanValue ) ) | 4549 | // InternalSolverLanguageParser.g:1789:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
| 3276 | { | 4550 | { |
| 3277 | // InternalSolverLanguage.g:1084:2: ( (lv_value_0_0= ruleBooleanValue ) ) | 4551 | // InternalSolverLanguageParser.g:1789:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
| 3278 | // InternalSolverLanguage.g:1085:3: (lv_value_0_0= ruleBooleanValue ) | 4552 | // InternalSolverLanguageParser.g:1790:3: ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) |
| 3279 | { | 4553 | { |
| 3280 | // InternalSolverLanguage.g:1085:3: (lv_value_0_0= ruleBooleanValue ) | 4554 | // InternalSolverLanguageParser.g:1790:3: ( (lv_functor_0_0= ruleReference ) ) |
| 3281 | // InternalSolverLanguage.g:1086:4: lv_value_0_0= ruleBooleanValue | 4555 | // InternalSolverLanguageParser.g:1791:4: (lv_functor_0_0= ruleReference ) |
| 4556 | { | ||
| 4557 | // InternalSolverLanguageParser.g:1791:4: (lv_functor_0_0= ruleReference ) | ||
| 4558 | // InternalSolverLanguageParser.g:1792:5: lv_functor_0_0= ruleReference | ||
| 3282 | { | 4559 | { |
| 3283 | 4560 | ||
| 3284 | newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); | 4561 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); |
| 3285 | 4562 | ||
| 4563 | pushFollow(FOLLOW_30); | ||
| 4564 | lv_functor_0_0=ruleReference(); | ||
| 4565 | |||
| 4566 | state._fsp--; | ||
| 4567 | |||
| 4568 | |||
| 4569 | if (current==null) { | ||
| 4570 | current = createModelElementForParent(grammarAccess.getCallRule()); | ||
| 4571 | } | ||
| 4572 | set( | ||
| 4573 | current, | ||
| 4574 | "functor", | ||
| 4575 | lv_functor_0_0, | ||
| 4576 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
| 4577 | afterParserOrEnumRuleCall(); | ||
| 4578 | |||
| 4579 | |||
| 4580 | } | ||
| 4581 | |||
| 4582 | |||
| 4583 | } | ||
| 4584 | |||
| 4585 | // InternalSolverLanguageParser.g:1809:3: ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? | ||
| 4586 | int alt21=3; | ||
| 4587 | int LA21_0 = input.LA(1); | ||
| 4588 | |||
| 4589 | if ( (LA21_0==RULE_TRANSITIVE_CLOSURE) ) { | ||
| 4590 | alt21=1; | ||
| 4591 | } | ||
| 4592 | else if ( (LA21_0==RULE_REFLEXIVE_TRANSITIVE_CLOSURE) ) { | ||
| 4593 | alt21=2; | ||
| 4594 | } | ||
| 4595 | switch (alt21) { | ||
| 4596 | case 1 : | ||
| 4597 | // InternalSolverLanguageParser.g:1810:4: ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ||
| 4598 | { | ||
| 4599 | // InternalSolverLanguageParser.g:1810:4: ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ||
| 4600 | // InternalSolverLanguageParser.g:1811:5: (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) | ||
| 4601 | { | ||
| 4602 | // InternalSolverLanguageParser.g:1811:5: (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) | ||
| 4603 | // InternalSolverLanguageParser.g:1812:6: lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE | ||
| 4604 | { | ||
| 4605 | lv_transitiveClosure_1_0=(Token)match(input,RULE_TRANSITIVE_CLOSURE,FOLLOW_11); | ||
| 4606 | |||
| 4607 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); | ||
| 4608 | |||
| 4609 | |||
| 4610 | if (current==null) { | ||
| 4611 | current = createModelElement(grammarAccess.getCallRule()); | ||
| 4612 | } | ||
| 4613 | setWithLastConsumed( | ||
| 4614 | current, | ||
| 4615 | "transitiveClosure", | ||
| 4616 | true, | ||
| 4617 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
| 4618 | |||
| 4619 | |||
| 4620 | } | ||
| 4621 | |||
| 4622 | |||
| 4623 | } | ||
| 4624 | |||
| 4625 | |||
| 4626 | } | ||
| 4627 | break; | ||
| 4628 | case 2 : | ||
| 4629 | // InternalSolverLanguageParser.g:1829:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) | ||
| 4630 | { | ||
| 4631 | // InternalSolverLanguageParser.g:1829:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) | ||
| 4632 | // InternalSolverLanguageParser.g:1830:5: (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) | ||
| 4633 | { | ||
| 4634 | // InternalSolverLanguageParser.g:1830:5: (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) | ||
| 4635 | // InternalSolverLanguageParser.g:1831:6: lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE | ||
| 4636 | { | ||
| 4637 | lv_reflexiveTransitiveClosure_2_0=(Token)match(input,RULE_REFLEXIVE_TRANSITIVE_CLOSURE,FOLLOW_11); | ||
| 4638 | |||
| 4639 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); | ||
| 4640 | |||
| 4641 | |||
| 4642 | if (current==null) { | ||
| 4643 | current = createModelElement(grammarAccess.getCallRule()); | ||
| 4644 | } | ||
| 4645 | setWithLastConsumed( | ||
| 4646 | current, | ||
| 4647 | "reflexiveTransitiveClosure", | ||
| 4648 | true, | ||
| 4649 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
| 4650 | |||
| 4651 | |||
| 4652 | } | ||
| 4653 | |||
| 4654 | |||
| 4655 | } | ||
| 4656 | |||
| 4657 | |||
| 4658 | } | ||
| 4659 | break; | ||
| 4660 | |||
| 4661 | } | ||
| 4662 | |||
| 4663 | // InternalSolverLanguageParser.g:1848:3: ( (lv_argumentList_3_0= ruleArgumentList ) ) | ||
| 4664 | // InternalSolverLanguageParser.g:1849:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
| 4665 | { | ||
| 4666 | // InternalSolverLanguageParser.g:1849:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
| 4667 | // InternalSolverLanguageParser.g:1850:5: lv_argumentList_3_0= ruleArgumentList | ||
| 4668 | { | ||
| 4669 | |||
| 4670 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
| 4671 | |||
| 3286 | pushFollow(FOLLOW_2); | 4672 | pushFollow(FOLLOW_2); |
| 3287 | lv_value_0_0=ruleBooleanValue(); | 4673 | lv_argumentList_3_0=ruleArgumentList(); |
| 3288 | 4674 | ||
| 3289 | state._fsp--; | 4675 | state._fsp--; |
| 3290 | 4676 | ||
| 3291 | 4677 | ||
| 3292 | if (current==null) { | 4678 | if (current==null) { |
| 3293 | current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); | 4679 | current = createModelElementForParent(grammarAccess.getCallRule()); |
| 3294 | } | 4680 | } |
| 3295 | set( | 4681 | set( |
| 3296 | current, | 4682 | current, |
| 3297 | "value", | 4683 | "argumentList", |
| 3298 | lv_value_0_0, | 4684 | lv_argumentList_3_0, |
| 3299 | "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | 4685 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); |
| 3300 | afterParserOrEnumRuleCall(); | 4686 | afterParserOrEnumRuleCall(); |
| 3301 | 4687 | ||
| 4688 | |||
| 4689 | } | ||
| 4690 | |||
| 3302 | 4691 | ||
| 3303 | } | 4692 | } |
| 3304 | 4693 | ||
| @@ -3321,28 +4710,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3321 | } | 4710 | } |
| 3322 | return current; | 4711 | return current; |
| 3323 | } | 4712 | } |
| 3324 | // $ANTLR end "ruleBooleanObject" | 4713 | // $ANTLR end "ruleCall" |
| 3325 | 4714 | ||
| 3326 | 4715 | ||
| 3327 | // $ANTLR start "entryRuleIntObject" | 4716 | // $ANTLR start "entryRuleArgumentList" |
| 3328 | // InternalSolverLanguage.g:1106:1: entryRuleIntObject returns [EObject current=null] : iv_ruleIntObject= ruleIntObject EOF ; | 4717 | // InternalSolverLanguageParser.g:1871:1: entryRuleArgumentList returns [EObject current=null] : iv_ruleArgumentList= ruleArgumentList EOF ; |
| 3329 | public final EObject entryRuleIntObject() throws RecognitionException { | 4718 | public final EObject entryRuleArgumentList() throws RecognitionException { |
| 3330 | EObject current = null; | 4719 | EObject current = null; |
| 3331 | 4720 | ||
| 3332 | EObject iv_ruleIntObject = null; | 4721 | EObject iv_ruleArgumentList = null; |
| 3333 | 4722 | ||
| 3334 | 4723 | ||
| 3335 | try { | 4724 | try { |
| 3336 | // InternalSolverLanguage.g:1106:50: (iv_ruleIntObject= ruleIntObject EOF ) | 4725 | // InternalSolverLanguageParser.g:1871:53: (iv_ruleArgumentList= ruleArgumentList EOF ) |
| 3337 | // InternalSolverLanguage.g:1107:2: iv_ruleIntObject= ruleIntObject EOF | 4726 | // InternalSolverLanguageParser.g:1872:2: iv_ruleArgumentList= ruleArgumentList EOF |
| 3338 | { | 4727 | { |
| 3339 | newCompositeNode(grammarAccess.getIntObjectRule()); | 4728 | newCompositeNode(grammarAccess.getArgumentListRule()); |
| 3340 | pushFollow(FOLLOW_1); | 4729 | pushFollow(FOLLOW_1); |
| 3341 | iv_ruleIntObject=ruleIntObject(); | 4730 | iv_ruleArgumentList=ruleArgumentList(); |
| 3342 | 4731 | ||
| 3343 | state._fsp--; | 4732 | state._fsp--; |
| 3344 | 4733 | ||
| 3345 | current =iv_ruleIntObject; | 4734 | current =iv_ruleArgumentList; |
| 3346 | match(input,EOF,FOLLOW_2); | 4735 | match(input,EOF,FOLLOW_2); |
| 3347 | 4736 | ||
| 3348 | } | 4737 | } |
| @@ -3357,53 +4746,314 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3357 | } | 4746 | } |
| 3358 | return current; | 4747 | return current; |
| 3359 | } | 4748 | } |
| 3360 | // $ANTLR end "entryRuleIntObject" | 4749 | // $ANTLR end "entryRuleArgumentList" |
| 3361 | 4750 | ||
| 3362 | 4751 | ||
| 3363 | // $ANTLR start "ruleIntObject" | 4752 | // $ANTLR start "ruleArgumentList" |
| 3364 | // InternalSolverLanguage.g:1113:1: ruleIntObject returns [EObject current=null] : ( (lv_value_0_0= ruleINTLiteral ) ) ; | 4753 | // InternalSolverLanguageParser.g:1878:1: ruleArgumentList returns [EObject current=null] : ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ; |
| 3365 | public final EObject ruleIntObject() throws RecognitionException { | 4754 | public final EObject ruleArgumentList() throws RecognitionException { |
| 3366 | EObject current = null; | 4755 | EObject current = null; |
| 3367 | 4756 | ||
| 3368 | AntlrDatatypeRuleToken lv_value_0_0 = null; | 4757 | Token otherlv_1=null; |
| 4758 | Token otherlv_3=null; | ||
| 4759 | Token otherlv_5=null; | ||
| 4760 | EObject lv_arguments_2_0 = null; | ||
| 4761 | |||
| 4762 | EObject lv_arguments_4_0 = null; | ||
| 3369 | 4763 | ||
| 3370 | 4764 | ||
| 3371 | 4765 | ||
| 3372 | enterRule(); | 4766 | enterRule(); |
| 3373 | 4767 | ||
| 3374 | try { | 4768 | try { |
| 3375 | // InternalSolverLanguage.g:1119:2: ( ( (lv_value_0_0= ruleINTLiteral ) ) ) | 4769 | // InternalSolverLanguageParser.g:1884:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ) |
| 3376 | // InternalSolverLanguage.g:1120:2: ( (lv_value_0_0= ruleINTLiteral ) ) | 4770 | // InternalSolverLanguageParser.g:1885:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) |
| 3377 | { | 4771 | { |
| 3378 | // InternalSolverLanguage.g:1120:2: ( (lv_value_0_0= ruleINTLiteral ) ) | 4772 | // InternalSolverLanguageParser.g:1885:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) |
| 3379 | // InternalSolverLanguage.g:1121:3: (lv_value_0_0= ruleINTLiteral ) | 4773 | // InternalSolverLanguageParser.g:1886:3: () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis |
| 3380 | { | 4774 | { |
| 3381 | // InternalSolverLanguage.g:1121:3: (lv_value_0_0= ruleINTLiteral ) | 4775 | // InternalSolverLanguageParser.g:1886:3: () |
| 3382 | // InternalSolverLanguage.g:1122:4: lv_value_0_0= ruleINTLiteral | 4776 | // InternalSolverLanguageParser.g:1887:4: |
| 3383 | { | 4777 | { |
| 3384 | 4778 | ||
| 3385 | newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); | 4779 | current = forceCreateModelElement( |
| 4780 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | ||
| 4781 | current); | ||
| 3386 | 4782 | ||
| 3387 | pushFollow(FOLLOW_2); | 4783 | |
| 3388 | lv_value_0_0=ruleINTLiteral(); | 4784 | } |
| 4785 | |||
| 4786 | otherlv_1=(Token)match(input,LeftParenthesis,FOLLOW_31); | ||
| 4787 | |||
| 4788 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
| 4789 | |||
| 4790 | // InternalSolverLanguageParser.g:1897:3: ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? | ||
| 4791 | int alt23=2; | ||
| 4792 | int LA23_0 = input.LA(1); | ||
| 4793 | |||
| 4794 | if ( (LA23_0==Current||LA23_0==Unknown||(LA23_0>=Count && LA23_0<=False)||(LA23_0>=Must && LA23_0<=Prod)||LA23_0==True||(LA23_0>=Avg && LA23_0<=Inf)||(LA23_0>=Max && LA23_0<=Sum)||(LA23_0>=ExclamationMark && LA23_0<=LeftParenthesis)||(LA23_0>=Asterisk && LA23_0<=PlusSign)||LA23_0==HyphenMinus||LA23_0==LeftSquareBracket||(LA23_0>=RULE_STRING && LA23_0<=RULE_QUOTED_ID)||(LA23_0>=RULE_ID && LA23_0<=RULE_INT)) ) { | ||
| 4795 | alt23=1; | ||
| 4796 | } | ||
| 4797 | switch (alt23) { | ||
| 4798 | case 1 : | ||
| 4799 | // InternalSolverLanguageParser.g:1898:4: ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
| 4800 | { | ||
| 4801 | // InternalSolverLanguageParser.g:1898:4: ( (lv_arguments_2_0= ruleArgument ) ) | ||
| 4802 | // InternalSolverLanguageParser.g:1899:5: (lv_arguments_2_0= ruleArgument ) | ||
| 4803 | { | ||
| 4804 | // InternalSolverLanguageParser.g:1899:5: (lv_arguments_2_0= ruleArgument ) | ||
| 4805 | // InternalSolverLanguageParser.g:1900:6: lv_arguments_2_0= ruleArgument | ||
| 4806 | { | ||
| 4807 | |||
| 4808 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
| 4809 | |||
| 4810 | pushFollow(FOLLOW_32); | ||
| 4811 | lv_arguments_2_0=ruleArgument(); | ||
| 4812 | |||
| 4813 | state._fsp--; | ||
| 4814 | |||
| 4815 | |||
| 4816 | if (current==null) { | ||
| 4817 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 4818 | } | ||
| 4819 | add( | ||
| 4820 | current, | ||
| 4821 | "arguments", | ||
| 4822 | lv_arguments_2_0, | ||
| 4823 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 4824 | afterParserOrEnumRuleCall(); | ||
| 4825 | |||
| 4826 | |||
| 4827 | } | ||
| 4828 | |||
| 4829 | |||
| 4830 | } | ||
| 4831 | |||
| 4832 | // InternalSolverLanguageParser.g:1917:4: (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
| 4833 | loop22: | ||
| 4834 | do { | ||
| 4835 | int alt22=2; | ||
| 4836 | int LA22_0 = input.LA(1); | ||
| 4837 | |||
| 4838 | if ( (LA22_0==Comma) ) { | ||
| 4839 | alt22=1; | ||
| 4840 | } | ||
| 4841 | |||
| 4842 | |||
| 4843 | switch (alt22) { | ||
| 4844 | case 1 : | ||
| 4845 | // InternalSolverLanguageParser.g:1918:5: otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) | ||
| 4846 | { | ||
| 4847 | otherlv_3=(Token)match(input,Comma,FOLLOW_33); | ||
| 4848 | |||
| 4849 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
| 4850 | |||
| 4851 | // InternalSolverLanguageParser.g:1922:5: ( (lv_arguments_4_0= ruleArgument ) ) | ||
| 4852 | // InternalSolverLanguageParser.g:1923:6: (lv_arguments_4_0= ruleArgument ) | ||
| 4853 | { | ||
| 4854 | // InternalSolverLanguageParser.g:1923:6: (lv_arguments_4_0= ruleArgument ) | ||
| 4855 | // InternalSolverLanguageParser.g:1924:7: lv_arguments_4_0= ruleArgument | ||
| 4856 | { | ||
| 4857 | |||
| 4858 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
| 4859 | |||
| 4860 | pushFollow(FOLLOW_32); | ||
| 4861 | lv_arguments_4_0=ruleArgument(); | ||
| 4862 | |||
| 4863 | state._fsp--; | ||
| 4864 | |||
| 4865 | |||
| 4866 | if (current==null) { | ||
| 4867 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
| 4868 | } | ||
| 4869 | add( | ||
| 4870 | current, | ||
| 4871 | "arguments", | ||
| 4872 | lv_arguments_4_0, | ||
| 4873 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 4874 | afterParserOrEnumRuleCall(); | ||
| 4875 | |||
| 4876 | |||
| 4877 | } | ||
| 4878 | |||
| 4879 | |||
| 4880 | } | ||
| 4881 | |||
| 4882 | |||
| 4883 | } | ||
| 4884 | break; | ||
| 4885 | |||
| 4886 | default : | ||
| 4887 | break loop22; | ||
| 4888 | } | ||
| 4889 | } while (true); | ||
| 4890 | |||
| 4891 | |||
| 4892 | } | ||
| 4893 | break; | ||
| 4894 | |||
| 4895 | } | ||
| 4896 | |||
| 4897 | otherlv_5=(Token)match(input,RightParenthesis,FOLLOW_2); | ||
| 4898 | |||
| 4899 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
| 4900 | |||
| 4901 | |||
| 4902 | } | ||
| 4903 | |||
| 4904 | |||
| 4905 | } | ||
| 4906 | |||
| 4907 | |||
| 4908 | leaveRule(); | ||
| 4909 | |||
| 4910 | } | ||
| 4911 | |||
| 4912 | catch (RecognitionException re) { | ||
| 4913 | recover(input,re); | ||
| 4914 | appendSkippedTokens(); | ||
| 4915 | } | ||
| 4916 | finally { | ||
| 4917 | } | ||
| 4918 | return current; | ||
| 4919 | } | ||
| 4920 | // $ANTLR end "ruleArgumentList" | ||
| 4921 | |||
| 4922 | |||
| 4923 | // $ANTLR start "entryRuleArgument" | ||
| 4924 | // InternalSolverLanguageParser.g:1951:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; | ||
| 4925 | public final EObject entryRuleArgument() throws RecognitionException { | ||
| 4926 | EObject current = null; | ||
| 4927 | |||
| 4928 | EObject iv_ruleArgument = null; | ||
| 4929 | |||
| 4930 | |||
| 4931 | try { | ||
| 4932 | // InternalSolverLanguageParser.g:1951:49: (iv_ruleArgument= ruleArgument EOF ) | ||
| 4933 | // InternalSolverLanguageParser.g:1952:2: iv_ruleArgument= ruleArgument EOF | ||
| 4934 | { | ||
| 4935 | newCompositeNode(grammarAccess.getArgumentRule()); | ||
| 4936 | pushFollow(FOLLOW_1); | ||
| 4937 | iv_ruleArgument=ruleArgument(); | ||
| 3389 | 4938 | ||
| 3390 | state._fsp--; | 4939 | state._fsp--; |
| 3391 | 4940 | ||
| 4941 | current =iv_ruleArgument; | ||
| 4942 | match(input,EOF,FOLLOW_2); | ||
| 3392 | 4943 | ||
| 3393 | if (current==null) { | 4944 | } |
| 3394 | current = createModelElementForParent(grammarAccess.getIntObjectRule()); | 4945 | |
| 3395 | } | 4946 | } |
| 3396 | set( | ||
| 3397 | current, | ||
| 3398 | "value", | ||
| 3399 | lv_value_0_0, | ||
| 3400 | "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | ||
| 3401 | afterParserOrEnumRuleCall(); | ||
| 3402 | |||
| 3403 | 4947 | ||
| 4948 | catch (RecognitionException re) { | ||
| 4949 | recover(input,re); | ||
| 4950 | appendSkippedTokens(); | ||
| 3404 | } | 4951 | } |
| 4952 | finally { | ||
| 4953 | } | ||
| 4954 | return current; | ||
| 4955 | } | ||
| 4956 | // $ANTLR end "entryRuleArgument" | ||
| 3405 | 4957 | ||
| 3406 | 4958 | ||
| 4959 | // $ANTLR start "ruleArgument" | ||
| 4960 | // InternalSolverLanguageParser.g:1958:1: ruleArgument returns [EObject current=null] : (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ; | ||
| 4961 | public final EObject ruleArgument() throws RecognitionException { | ||
| 4962 | EObject current = null; | ||
| 4963 | |||
| 4964 | EObject this_ExpressionArgument_0 = null; | ||
| 4965 | |||
| 4966 | EObject this_StarArgument_1 = null; | ||
| 4967 | |||
| 4968 | EObject this_TypedArgument_2 = null; | ||
| 4969 | |||
| 4970 | EObject this_TypedStarArgument_3 = null; | ||
| 4971 | |||
| 4972 | |||
| 4973 | |||
| 4974 | enterRule(); | ||
| 4975 | |||
| 4976 | try { | ||
| 4977 | // InternalSolverLanguageParser.g:1964:2: ( (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ) | ||
| 4978 | // InternalSolverLanguageParser.g:1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | ||
| 4979 | { | ||
| 4980 | // InternalSolverLanguageParser.g:1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | ||
| 4981 | int alt24=4; | ||
| 4982 | alt24 = dfa24.predict(input); | ||
| 4983 | switch (alt24) { | ||
| 4984 | case 1 : | ||
| 4985 | // InternalSolverLanguageParser.g:1966:3: this_ExpressionArgument_0= ruleExpressionArgument | ||
| 4986 | { | ||
| 4987 | |||
| 4988 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
| 4989 | |||
| 4990 | pushFollow(FOLLOW_2); | ||
| 4991 | this_ExpressionArgument_0=ruleExpressionArgument(); | ||
| 4992 | |||
| 4993 | state._fsp--; | ||
| 4994 | |||
| 4995 | |||
| 4996 | current = this_ExpressionArgument_0; | ||
| 4997 | afterParserOrEnumRuleCall(); | ||
| 4998 | |||
| 4999 | |||
| 5000 | } | ||
| 5001 | break; | ||
| 5002 | case 2 : | ||
| 5003 | // InternalSolverLanguageParser.g:1975:3: this_StarArgument_1= ruleStarArgument | ||
| 5004 | { | ||
| 5005 | |||
| 5006 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
| 5007 | |||
| 5008 | pushFollow(FOLLOW_2); | ||
| 5009 | this_StarArgument_1=ruleStarArgument(); | ||
| 5010 | |||
| 5011 | state._fsp--; | ||
| 5012 | |||
| 5013 | |||
| 5014 | current = this_StarArgument_1; | ||
| 5015 | afterParserOrEnumRuleCall(); | ||
| 5016 | |||
| 5017 | |||
| 5018 | } | ||
| 5019 | break; | ||
| 5020 | case 3 : | ||
| 5021 | // InternalSolverLanguageParser.g:1984:3: this_TypedArgument_2= ruleTypedArgument | ||
| 5022 | { | ||
| 5023 | |||
| 5024 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | ||
| 5025 | |||
| 5026 | pushFollow(FOLLOW_2); | ||
| 5027 | this_TypedArgument_2=ruleTypedArgument(); | ||
| 5028 | |||
| 5029 | state._fsp--; | ||
| 5030 | |||
| 5031 | |||
| 5032 | current = this_TypedArgument_2; | ||
| 5033 | afterParserOrEnumRuleCall(); | ||
| 5034 | |||
| 5035 | |||
| 5036 | } | ||
| 5037 | break; | ||
| 5038 | case 4 : | ||
| 5039 | // InternalSolverLanguageParser.g:1993:3: this_TypedStarArgument_3= ruleTypedStarArgument | ||
| 5040 | { | ||
| 5041 | |||
| 5042 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
| 5043 | |||
| 5044 | pushFollow(FOLLOW_2); | ||
| 5045 | this_TypedStarArgument_3=ruleTypedStarArgument(); | ||
| 5046 | |||
| 5047 | state._fsp--; | ||
| 5048 | |||
| 5049 | |||
| 5050 | current = this_TypedStarArgument_3; | ||
| 5051 | afterParserOrEnumRuleCall(); | ||
| 5052 | |||
| 5053 | |||
| 5054 | } | ||
| 5055 | break; | ||
| 5056 | |||
| 3407 | } | 5057 | } |
| 3408 | 5058 | ||
| 3409 | 5059 | ||
| @@ -3422,28 +5072,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3422 | } | 5072 | } |
| 3423 | return current; | 5073 | return current; |
| 3424 | } | 5074 | } |
| 3425 | // $ANTLR end "ruleIntObject" | 5075 | // $ANTLR end "ruleArgument" |
| 3426 | 5076 | ||
| 3427 | 5077 | ||
| 3428 | // $ANTLR start "entryRuleRealObject" | 5078 | // $ANTLR start "entryRuleExpressionArgument" |
| 3429 | // InternalSolverLanguage.g:1142:1: entryRuleRealObject returns [EObject current=null] : iv_ruleRealObject= ruleRealObject EOF ; | 5079 | // InternalSolverLanguageParser.g:2005:1: entryRuleExpressionArgument returns [EObject current=null] : iv_ruleExpressionArgument= ruleExpressionArgument EOF ; |
| 3430 | public final EObject entryRuleRealObject() throws RecognitionException { | 5080 | public final EObject entryRuleExpressionArgument() throws RecognitionException { |
| 3431 | EObject current = null; | 5081 | EObject current = null; |
| 3432 | 5082 | ||
| 3433 | EObject iv_ruleRealObject = null; | 5083 | EObject iv_ruleExpressionArgument = null; |
| 3434 | 5084 | ||
| 3435 | 5085 | ||
| 3436 | try { | 5086 | try { |
| 3437 | // InternalSolverLanguage.g:1142:51: (iv_ruleRealObject= ruleRealObject EOF ) | 5087 | // InternalSolverLanguageParser.g:2005:59: (iv_ruleExpressionArgument= ruleExpressionArgument EOF ) |
| 3438 | // InternalSolverLanguage.g:1143:2: iv_ruleRealObject= ruleRealObject EOF | 5088 | // InternalSolverLanguageParser.g:2006:2: iv_ruleExpressionArgument= ruleExpressionArgument EOF |
| 3439 | { | 5089 | { |
| 3440 | newCompositeNode(grammarAccess.getRealObjectRule()); | 5090 | newCompositeNode(grammarAccess.getExpressionArgumentRule()); |
| 3441 | pushFollow(FOLLOW_1); | 5091 | pushFollow(FOLLOW_1); |
| 3442 | iv_ruleRealObject=ruleRealObject(); | 5092 | iv_ruleExpressionArgument=ruleExpressionArgument(); |
| 3443 | 5093 | ||
| 3444 | state._fsp--; | 5094 | state._fsp--; |
| 3445 | 5095 | ||
| 3446 | current =iv_ruleRealObject; | 5096 | current =iv_ruleExpressionArgument; |
| 3447 | match(input,EOF,FOLLOW_2); | 5097 | match(input,EOF,FOLLOW_2); |
| 3448 | 5098 | ||
| 3449 | } | 5099 | } |
| @@ -3458,47 +5108,47 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3458 | } | 5108 | } |
| 3459 | return current; | 5109 | return current; |
| 3460 | } | 5110 | } |
| 3461 | // $ANTLR end "entryRuleRealObject" | 5111 | // $ANTLR end "entryRuleExpressionArgument" |
| 3462 | 5112 | ||
| 3463 | 5113 | ||
| 3464 | // $ANTLR start "ruleRealObject" | 5114 | // $ANTLR start "ruleExpressionArgument" |
| 3465 | // InternalSolverLanguage.g:1149:1: ruleRealObject returns [EObject current=null] : ( (lv_value_0_0= ruleREALLiteral ) ) ; | 5115 | // InternalSolverLanguageParser.g:2012:1: ruleExpressionArgument returns [EObject current=null] : ( (lv_body_0_0= ruleComparisonExpression ) ) ; |
| 3466 | public final EObject ruleRealObject() throws RecognitionException { | 5116 | public final EObject ruleExpressionArgument() throws RecognitionException { |
| 3467 | EObject current = null; | 5117 | EObject current = null; |
| 3468 | 5118 | ||
| 3469 | AntlrDatatypeRuleToken lv_value_0_0 = null; | 5119 | EObject lv_body_0_0 = null; |
| 3470 | 5120 | ||
| 3471 | 5121 | ||
| 3472 | 5122 | ||
| 3473 | enterRule(); | 5123 | enterRule(); |
| 3474 | 5124 | ||
| 3475 | try { | 5125 | try { |
| 3476 | // InternalSolverLanguage.g:1155:2: ( ( (lv_value_0_0= ruleREALLiteral ) ) ) | 5126 | // InternalSolverLanguageParser.g:2018:2: ( ( (lv_body_0_0= ruleComparisonExpression ) ) ) |
| 3477 | // InternalSolverLanguage.g:1156:2: ( (lv_value_0_0= ruleREALLiteral ) ) | 5127 | // InternalSolverLanguageParser.g:2019:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
| 3478 | { | 5128 | { |
| 3479 | // InternalSolverLanguage.g:1156:2: ( (lv_value_0_0= ruleREALLiteral ) ) | 5129 | // InternalSolverLanguageParser.g:2019:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
| 3480 | // InternalSolverLanguage.g:1157:3: (lv_value_0_0= ruleREALLiteral ) | 5130 | // InternalSolverLanguageParser.g:2020:3: (lv_body_0_0= ruleComparisonExpression ) |
| 3481 | { | 5131 | { |
| 3482 | // InternalSolverLanguage.g:1157:3: (lv_value_0_0= ruleREALLiteral ) | 5132 | // InternalSolverLanguageParser.g:2020:3: (lv_body_0_0= ruleComparisonExpression ) |
| 3483 | // InternalSolverLanguage.g:1158:4: lv_value_0_0= ruleREALLiteral | 5133 | // InternalSolverLanguageParser.g:2021:4: lv_body_0_0= ruleComparisonExpression |
| 3484 | { | 5134 | { |
| 3485 | 5135 | ||
| 3486 | newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); | 5136 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); |
| 3487 | 5137 | ||
| 3488 | pushFollow(FOLLOW_2); | 5138 | pushFollow(FOLLOW_2); |
| 3489 | lv_value_0_0=ruleREALLiteral(); | 5139 | lv_body_0_0=ruleComparisonExpression(); |
| 3490 | 5140 | ||
| 3491 | state._fsp--; | 5141 | state._fsp--; |
| 3492 | 5142 | ||
| 3493 | 5143 | ||
| 3494 | if (current==null) { | 5144 | if (current==null) { |
| 3495 | current = createModelElementForParent(grammarAccess.getRealObjectRule()); | 5145 | current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); |
| 3496 | } | 5146 | } |
| 3497 | set( | 5147 | set( |
| 3498 | current, | 5148 | current, |
| 3499 | "value", | 5149 | "body", |
| 3500 | lv_value_0_0, | 5150 | lv_body_0_0, |
| 3501 | "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | 5151 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); |
| 3502 | afterParserOrEnumRuleCall(); | 5152 | afterParserOrEnumRuleCall(); |
| 3503 | 5153 | ||
| 3504 | 5154 | ||
| @@ -3523,28 +5173,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3523 | } | 5173 | } |
| 3524 | return current; | 5174 | return current; |
| 3525 | } | 5175 | } |
| 3526 | // $ANTLR end "ruleRealObject" | 5176 | // $ANTLR end "ruleExpressionArgument" |
| 3527 | 5177 | ||
| 3528 | 5178 | ||
| 3529 | // $ANTLR start "entryRuleStringObject" | 5179 | // $ANTLR start "entryRuleStarArgument" |
| 3530 | // InternalSolverLanguage.g:1178:1: entryRuleStringObject returns [EObject current=null] : iv_ruleStringObject= ruleStringObject EOF ; | 5180 | // InternalSolverLanguageParser.g:2041:1: entryRuleStarArgument returns [EObject current=null] : iv_ruleStarArgument= ruleStarArgument EOF ; |
| 3531 | public final EObject entryRuleStringObject() throws RecognitionException { | 5181 | public final EObject entryRuleStarArgument() throws RecognitionException { |
| 3532 | EObject current = null; | 5182 | EObject current = null; |
| 3533 | 5183 | ||
| 3534 | EObject iv_ruleStringObject = null; | 5184 | EObject iv_ruleStarArgument = null; |
| 3535 | 5185 | ||
| 3536 | 5186 | ||
| 3537 | try { | 5187 | try { |
| 3538 | // InternalSolverLanguage.g:1178:53: (iv_ruleStringObject= ruleStringObject EOF ) | 5188 | // InternalSolverLanguageParser.g:2041:53: (iv_ruleStarArgument= ruleStarArgument EOF ) |
| 3539 | // InternalSolverLanguage.g:1179:2: iv_ruleStringObject= ruleStringObject EOF | 5189 | // InternalSolverLanguageParser.g:2042:2: iv_ruleStarArgument= ruleStarArgument EOF |
| 3540 | { | 5190 | { |
| 3541 | newCompositeNode(grammarAccess.getStringObjectRule()); | 5191 | newCompositeNode(grammarAccess.getStarArgumentRule()); |
| 3542 | pushFollow(FOLLOW_1); | 5192 | pushFollow(FOLLOW_1); |
| 3543 | iv_ruleStringObject=ruleStringObject(); | 5193 | iv_ruleStarArgument=ruleStarArgument(); |
| 3544 | 5194 | ||
| 3545 | state._fsp--; | 5195 | state._fsp--; |
| 3546 | 5196 | ||
| 3547 | current =iv_ruleStringObject; | 5197 | current =iv_ruleStarArgument; |
| 3548 | match(input,EOF,FOLLOW_2); | 5198 | match(input,EOF,FOLLOW_2); |
| 3549 | 5199 | ||
| 3550 | } | 5200 | } |
| @@ -3559,46 +5209,41 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3559 | } | 5209 | } |
| 3560 | return current; | 5210 | return current; |
| 3561 | } | 5211 | } |
| 3562 | // $ANTLR end "entryRuleStringObject" | 5212 | // $ANTLR end "entryRuleStarArgument" |
| 3563 | 5213 | ||
| 3564 | 5214 | ||
| 3565 | // $ANTLR start "ruleStringObject" | 5215 | // $ANTLR start "ruleStarArgument" |
| 3566 | // InternalSolverLanguage.g:1185:1: ruleStringObject returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | 5216 | // InternalSolverLanguageParser.g:2048:1: ruleStarArgument returns [EObject current=null] : ( () otherlv_1= Asterisk ) ; |
| 3567 | public final EObject ruleStringObject() throws RecognitionException { | 5217 | public final EObject ruleStarArgument() throws RecognitionException { |
| 3568 | EObject current = null; | 5218 | EObject current = null; |
| 3569 | 5219 | ||
| 3570 | Token lv_value_0_0=null; | 5220 | Token otherlv_1=null; |
| 3571 | 5221 | ||
| 3572 | 5222 | ||
| 3573 | enterRule(); | 5223 | enterRule(); |
| 3574 | 5224 | ||
| 3575 | try { | 5225 | try { |
| 3576 | // InternalSolverLanguage.g:1191:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) | 5226 | // InternalSolverLanguageParser.g:2054:2: ( ( () otherlv_1= Asterisk ) ) |
| 3577 | // InternalSolverLanguage.g:1192:2: ( (lv_value_0_0= RULE_STRING ) ) | 5227 | // InternalSolverLanguageParser.g:2055:2: ( () otherlv_1= Asterisk ) |
| 3578 | { | 5228 | { |
| 3579 | // InternalSolverLanguage.g:1192:2: ( (lv_value_0_0= RULE_STRING ) ) | 5229 | // InternalSolverLanguageParser.g:2055:2: ( () otherlv_1= Asterisk ) |
| 3580 | // InternalSolverLanguage.g:1193:3: (lv_value_0_0= RULE_STRING ) | 5230 | // InternalSolverLanguageParser.g:2056:3: () otherlv_1= Asterisk |
| 3581 | { | 5231 | { |
| 3582 | // InternalSolverLanguage.g:1193:3: (lv_value_0_0= RULE_STRING ) | 5232 | // InternalSolverLanguageParser.g:2056:3: () |
| 3583 | // InternalSolverLanguage.g:1194:4: lv_value_0_0= RULE_STRING | 5233 | // InternalSolverLanguageParser.g:2057:4: |
| 3584 | { | 5234 | { |
| 3585 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); | ||
| 3586 | |||
| 3587 | newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); | ||
| 3588 | |||
| 3589 | 5235 | ||
| 3590 | if (current==null) { | 5236 | current = forceCreateModelElement( |
| 3591 | current = createModelElement(grammarAccess.getStringObjectRule()); | 5237 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), |
| 3592 | } | 5238 | current); |
| 3593 | setWithLastConsumed( | ||
| 3594 | current, | ||
| 3595 | "value", | ||
| 3596 | lv_value_0_0, | ||
| 3597 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 3598 | 5239 | ||
| 3599 | 5240 | ||
| 3600 | } | 5241 | } |
| 3601 | 5242 | ||
| 5243 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); | ||
| 5244 | |||
| 5245 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
| 5246 | |||
| 3602 | 5247 | ||
| 3603 | } | 5248 | } |
| 3604 | 5249 | ||
| @@ -3618,28 +5263,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3618 | } | 5263 | } |
| 3619 | return current; | 5264 | return current; |
| 3620 | } | 5265 | } |
| 3621 | // $ANTLR end "ruleStringObject" | 5266 | // $ANTLR end "ruleStarArgument" |
| 3622 | 5267 | ||
| 3623 | 5268 | ||
| 3624 | // $ANTLR start "entryRulePredicate" | 5269 | // $ANTLR start "entryRuleTypedArgument" |
| 3625 | // InternalSolverLanguage.g:1213:1: entryRulePredicate returns [EObject current=null] : iv_rulePredicate= rulePredicate EOF ; | 5270 | // InternalSolverLanguageParser.g:2071:1: entryRuleTypedArgument returns [EObject current=null] : iv_ruleTypedArgument= ruleTypedArgument EOF ; |
| 3626 | public final EObject entryRulePredicate() throws RecognitionException { | 5271 | public final EObject entryRuleTypedArgument() throws RecognitionException { |
| 3627 | EObject current = null; | 5272 | EObject current = null; |
| 3628 | 5273 | ||
| 3629 | EObject iv_rulePredicate = null; | 5274 | EObject iv_ruleTypedArgument = null; |
| 3630 | 5275 | ||
| 3631 | 5276 | ||
| 3632 | try { | 5277 | try { |
| 3633 | // InternalSolverLanguage.g:1213:50: (iv_rulePredicate= rulePredicate EOF ) | 5278 | // InternalSolverLanguageParser.g:2071:54: (iv_ruleTypedArgument= ruleTypedArgument EOF ) |
| 3634 | // InternalSolverLanguage.g:1214:2: iv_rulePredicate= rulePredicate EOF | 5279 | // InternalSolverLanguageParser.g:2072:2: iv_ruleTypedArgument= ruleTypedArgument EOF |
| 3635 | { | 5280 | { |
| 3636 | newCompositeNode(grammarAccess.getPredicateRule()); | 5281 | newCompositeNode(grammarAccess.getTypedArgumentRule()); |
| 3637 | pushFollow(FOLLOW_1); | 5282 | pushFollow(FOLLOW_1); |
| 3638 | iv_rulePredicate=rulePredicate(); | 5283 | iv_ruleTypedArgument=ruleTypedArgument(); |
| 3639 | 5284 | ||
| 3640 | state._fsp--; | 5285 | state._fsp--; |
| 3641 | 5286 | ||
| 3642 | current =iv_rulePredicate; | 5287 | current =iv_ruleTypedArgument; |
| 3643 | match(input,EOF,FOLLOW_2); | 5288 | match(input,EOF,FOLLOW_2); |
| 3644 | 5289 | ||
| 3645 | } | 5290 | } |
| @@ -3654,99 +5299,72 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3654 | } | 5299 | } |
| 3655 | return current; | 5300 | return current; |
| 3656 | } | 5301 | } |
| 3657 | // $ANTLR end "entryRulePredicate" | 5302 | // $ANTLR end "entryRuleTypedArgument" |
| 3658 | 5303 | ||
| 3659 | 5304 | ||
| 3660 | // $ANTLR start "rulePredicate" | 5305 | // $ANTLR start "ruleTypedArgument" |
| 3661 | // InternalSolverLanguage.g:1220:1: rulePredicate returns [EObject current=null] : ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) ; | 5306 | // InternalSolverLanguageParser.g:2078:1: ruleTypedArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ; |
| 3662 | public final EObject rulePredicate() throws RecognitionException { | 5307 | public final EObject ruleTypedArgument() throws RecognitionException { |
| 3663 | EObject current = null; | 5308 | EObject current = null; |
| 3664 | 5309 | ||
| 3665 | Token lv_isError_0_0=null; | ||
| 3666 | Token otherlv_2=null; | ||
| 3667 | Token otherlv_4=null; | ||
| 3668 | Token otherlv_6=null; | ||
| 3669 | Token otherlv_7=null; | ||
| 3670 | Token otherlv_8=null; | ||
| 3671 | Token otherlv_10=null; | ||
| 3672 | Token otherlv_12=null; | ||
| 3673 | EObject lv_symbol_1_0 = null; | ||
| 3674 | |||
| 3675 | EObject lv_parameters_3_0 = null; | ||
| 3676 | |||
| 3677 | EObject lv_parameters_5_0 = null; | ||
| 3678 | |||
| 3679 | EObject lv_bodies_9_0 = null; | ||
| 3680 | |||
| 3681 | EObject lv_bodies_11_0 = null; | ||
| 3682 | |||
| 3683 | |||
| 3684 | 5310 | ||
| 3685 | enterRule(); | 5311 | enterRule(); |
| 3686 | 5312 | ||
| 3687 | try { | 5313 | try { |
| 3688 | // InternalSolverLanguage.g:1226:2: ( ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) ) | 5314 | // InternalSolverLanguageParser.g:2084:2: ( ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ) |
| 3689 | // InternalSolverLanguage.g:1227:2: ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) | 5315 | // InternalSolverLanguageParser.g:2085:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) |
| 3690 | { | 5316 | { |
| 3691 | // InternalSolverLanguage.g:1227:2: ( ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' ) | 5317 | // InternalSolverLanguageParser.g:2085:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) |
| 3692 | // InternalSolverLanguage.g:1228:3: ( (lv_isError_0_0= 'error' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? otherlv_7= ':-' (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) otherlv_12= '.' | 5318 | // InternalSolverLanguageParser.g:2086:3: ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) |
| 5319 | { | ||
| 5320 | // InternalSolverLanguageParser.g:2086:3: ( ( ruleQualifiedName ) ) | ||
| 5321 | // InternalSolverLanguageParser.g:2087:4: ( ruleQualifiedName ) | ||
| 5322 | { | ||
| 5323 | // InternalSolverLanguageParser.g:2087:4: ( ruleQualifiedName ) | ||
| 5324 | // InternalSolverLanguageParser.g:2088:5: ruleQualifiedName | ||
| 3693 | { | 5325 | { |
| 3694 | // InternalSolverLanguage.g:1228:3: ( (lv_isError_0_0= 'error' ) )? | ||
| 3695 | int alt17=2; | ||
| 3696 | int LA17_0 = input.LA(1); | ||
| 3697 | 5326 | ||
| 3698 | if ( (LA17_0==16) ) { | 5327 | if (current==null) { |
| 3699 | alt17=1; | 5328 | current = createModelElement(grammarAccess.getTypedArgumentRule()); |
| 3700 | } | 5329 | } |
| 3701 | switch (alt17) { | 5330 | |
| 3702 | case 1 : | ||
| 3703 | // InternalSolverLanguage.g:1229:4: (lv_isError_0_0= 'error' ) | ||
| 3704 | { | ||
| 3705 | // InternalSolverLanguage.g:1229:4: (lv_isError_0_0= 'error' ) | ||
| 3706 | // InternalSolverLanguage.g:1230:5: lv_isError_0_0= 'error' | ||
| 3707 | { | ||
| 3708 | lv_isError_0_0=(Token)match(input,16,FOLLOW_12); | ||
| 3709 | 5331 | ||
| 3710 | newLeafNode(lv_isError_0_0, grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); | 5332 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
| 3711 | 5333 | ||
| 5334 | pushFollow(FOLLOW_8); | ||
| 5335 | ruleQualifiedName(); | ||
| 3712 | 5336 | ||
| 3713 | if (current==null) { | 5337 | state._fsp--; |
| 3714 | current = createModelElement(grammarAccess.getPredicateRule()); | ||
| 3715 | } | ||
| 3716 | setWithLastConsumed(current, "isError", true, "error"); | ||
| 3717 | |||
| 3718 | 5338 | ||
| 3719 | } | ||
| 3720 | 5339 | ||
| 5340 | afterParserOrEnumRuleCall(); | ||
| 5341 | |||
| 5342 | |||
| 5343 | } | ||
| 3721 | 5344 | ||
| 3722 | } | ||
| 3723 | break; | ||
| 3724 | 5345 | ||
| 3725 | } | 5346 | } |
| 3726 | 5347 | ||
| 3727 | // InternalSolverLanguage.g:1242:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) | 5348 | // InternalSolverLanguageParser.g:2102:3: ( ( ruleQualifiedName ) ) |
| 3728 | // InternalSolverLanguage.g:1243:4: (lv_symbol_1_0= ruleModelSymbol ) | 5349 | // InternalSolverLanguageParser.g:2103:4: ( ruleQualifiedName ) |
| 3729 | { | 5350 | { |
| 3730 | // InternalSolverLanguage.g:1243:4: (lv_symbol_1_0= ruleModelSymbol ) | 5351 | // InternalSolverLanguageParser.g:2103:4: ( ruleQualifiedName ) |
| 3731 | // InternalSolverLanguage.g:1244:5: lv_symbol_1_0= ruleModelSymbol | 5352 | // InternalSolverLanguageParser.g:2104:5: ruleQualifiedName |
| 3732 | { | 5353 | { |
| 3733 | 5354 | ||
| 3734 | newCompositeNode(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 5355 | if (current==null) { |
| 5356 | current = createModelElement(grammarAccess.getTypedArgumentRule()); | ||
| 5357 | } | ||
| 5358 | |||
| 5359 | |||
| 5360 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | ||
| 3735 | 5361 | ||
| 3736 | pushFollow(FOLLOW_14); | 5362 | pushFollow(FOLLOW_2); |
| 3737 | lv_symbol_1_0=ruleModelSymbol(); | 5363 | ruleQualifiedName(); |
| 3738 | 5364 | ||
| 3739 | state._fsp--; | 5365 | state._fsp--; |
| 3740 | 5366 | ||
| 3741 | 5367 | ||
| 3742 | if (current==null) { | ||
| 3743 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3744 | } | ||
| 3745 | set( | ||
| 3746 | current, | ||
| 3747 | "symbol", | ||
| 3748 | lv_symbol_1_0, | ||
| 3749 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 3750 | afterParserOrEnumRuleCall(); | 5368 | afterParserOrEnumRuleCall(); |
| 3751 | 5369 | ||
| 3752 | 5370 | ||
| @@ -3755,278 +5373,208 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 3755 | 5373 | ||
| 3756 | } | 5374 | } |
| 3757 | 5375 | ||
| 3758 | // InternalSolverLanguage.g:1261:3: (otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' )? | ||
| 3759 | int alt20=2; | ||
| 3760 | int LA20_0 = input.LA(1); | ||
| 3761 | 5376 | ||
| 3762 | if ( (LA20_0==17) ) { | ||
| 3763 | alt20=1; | ||
| 3764 | } | 5377 | } |
| 3765 | switch (alt20) { | ||
| 3766 | case 1 : | ||
| 3767 | // InternalSolverLanguage.g:1262:4: otherlv_2= '(' ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? otherlv_6= ')' | ||
| 3768 | { | ||
| 3769 | otherlv_2=(Token)match(input,17,FOLLOW_15); | ||
| 3770 | |||
| 3771 | newLeafNode(otherlv_2, grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); | ||
| 3772 | |||
| 3773 | // InternalSolverLanguage.g:1266:4: ( ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* )? | ||
| 3774 | int alt19=2; | ||
| 3775 | int LA19_0 = input.LA(1); | ||
| 3776 | 5378 | ||
| 3777 | if ( (LA19_0==RULE_ID) ) { | ||
| 3778 | alt19=1; | ||
| 3779 | } | ||
| 3780 | switch (alt19) { | ||
| 3781 | case 1 : | ||
| 3782 | // InternalSolverLanguage.g:1267:5: ( (lv_parameters_3_0= ruleParameter ) ) (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* | ||
| 3783 | { | ||
| 3784 | // InternalSolverLanguage.g:1267:5: ( (lv_parameters_3_0= ruleParameter ) ) | ||
| 3785 | // InternalSolverLanguage.g:1268:6: (lv_parameters_3_0= ruleParameter ) | ||
| 3786 | { | ||
| 3787 | // InternalSolverLanguage.g:1268:6: (lv_parameters_3_0= ruleParameter ) | ||
| 3788 | // InternalSolverLanguage.g:1269:7: lv_parameters_3_0= ruleParameter | ||
| 3789 | { | ||
| 3790 | 5379 | ||
| 3791 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); | 5380 | } |
| 3792 | |||
| 3793 | pushFollow(FOLLOW_8); | ||
| 3794 | lv_parameters_3_0=ruleParameter(); | ||
| 3795 | 5381 | ||
| 3796 | state._fsp--; | ||
| 3797 | 5382 | ||
| 5383 | leaveRule(); | ||
| 3798 | 5384 | ||
| 3799 | if (current==null) { | 5385 | } |
| 3800 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3801 | } | ||
| 3802 | add( | ||
| 3803 | current, | ||
| 3804 | "parameters", | ||
| 3805 | lv_parameters_3_0, | ||
| 3806 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 3807 | afterParserOrEnumRuleCall(); | ||
| 3808 | |||
| 3809 | 5386 | ||
| 3810 | } | 5387 | catch (RecognitionException re) { |
| 5388 | recover(input,re); | ||
| 5389 | appendSkippedTokens(); | ||
| 5390 | } | ||
| 5391 | finally { | ||
| 5392 | } | ||
| 5393 | return current; | ||
| 5394 | } | ||
| 5395 | // $ANTLR end "ruleTypedArgument" | ||
| 3811 | 5396 | ||
| 3812 | 5397 | ||
| 3813 | } | 5398 | // $ANTLR start "entryRuleTypedStarArgument" |
| 5399 | // InternalSolverLanguageParser.g:2122:1: entryRuleTypedStarArgument returns [EObject current=null] : iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ; | ||
| 5400 | public final EObject entryRuleTypedStarArgument() throws RecognitionException { | ||
| 5401 | EObject current = null; | ||
| 3814 | 5402 | ||
| 3815 | // InternalSolverLanguage.g:1286:5: (otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) )* | 5403 | EObject iv_ruleTypedStarArgument = null; |
| 3816 | loop18: | ||
| 3817 | do { | ||
| 3818 | int alt18=2; | ||
| 3819 | int LA18_0 = input.LA(1); | ||
| 3820 | 5404 | ||
| 3821 | if ( (LA18_0==18) ) { | ||
| 3822 | alt18=1; | ||
| 3823 | } | ||
| 3824 | 5405 | ||
| 5406 | try { | ||
| 5407 | // InternalSolverLanguageParser.g:2122:58: (iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ) | ||
| 5408 | // InternalSolverLanguageParser.g:2123:2: iv_ruleTypedStarArgument= ruleTypedStarArgument EOF | ||
| 5409 | { | ||
| 5410 | newCompositeNode(grammarAccess.getTypedStarArgumentRule()); | ||
| 5411 | pushFollow(FOLLOW_1); | ||
| 5412 | iv_ruleTypedStarArgument=ruleTypedStarArgument(); | ||
| 3825 | 5413 | ||
| 3826 | switch (alt18) { | 5414 | state._fsp--; |
| 3827 | case 1 : | ||
| 3828 | // InternalSolverLanguage.g:1287:6: otherlv_4= ',' ( (lv_parameters_5_0= ruleParameter ) ) | ||
| 3829 | { | ||
| 3830 | otherlv_4=(Token)match(input,18,FOLLOW_12); | ||
| 3831 | 5415 | ||
| 3832 | newLeafNode(otherlv_4, grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); | 5416 | current =iv_ruleTypedStarArgument; |
| 3833 | 5417 | match(input,EOF,FOLLOW_2); | |
| 3834 | // InternalSolverLanguage.g:1291:6: ( (lv_parameters_5_0= ruleParameter ) ) | ||
| 3835 | // InternalSolverLanguage.g:1292:7: (lv_parameters_5_0= ruleParameter ) | ||
| 3836 | { | ||
| 3837 | // InternalSolverLanguage.g:1292:7: (lv_parameters_5_0= ruleParameter ) | ||
| 3838 | // InternalSolverLanguage.g:1293:8: lv_parameters_5_0= ruleParameter | ||
| 3839 | { | ||
| 3840 | 5418 | ||
| 3841 | newCompositeNode(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); | 5419 | } |
| 3842 | |||
| 3843 | pushFollow(FOLLOW_8); | ||
| 3844 | lv_parameters_5_0=ruleParameter(); | ||
| 3845 | 5420 | ||
| 3846 | state._fsp--; | 5421 | } |
| 3847 | 5422 | ||
| 5423 | catch (RecognitionException re) { | ||
| 5424 | recover(input,re); | ||
| 5425 | appendSkippedTokens(); | ||
| 5426 | } | ||
| 5427 | finally { | ||
| 5428 | } | ||
| 5429 | return current; | ||
| 5430 | } | ||
| 5431 | // $ANTLR end "entryRuleTypedStarArgument" | ||
| 3848 | 5432 | ||
| 3849 | if (current==null) { | ||
| 3850 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3851 | } | ||
| 3852 | add( | ||
| 3853 | current, | ||
| 3854 | "parameters", | ||
| 3855 | lv_parameters_5_0, | ||
| 3856 | "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | ||
| 3857 | afterParserOrEnumRuleCall(); | ||
| 3858 | |||
| 3859 | 5433 | ||
| 3860 | } | 5434 | // $ANTLR start "ruleTypedStarArgument" |
| 5435 | // InternalSolverLanguageParser.g:2129:1: ruleTypedStarArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) ; | ||
| 5436 | public final EObject ruleTypedStarArgument() throws RecognitionException { | ||
| 5437 | EObject current = null; | ||
| 3861 | 5438 | ||
| 5439 | Token otherlv_1=null; | ||
| 3862 | 5440 | ||
| 3863 | } | ||
| 3864 | 5441 | ||
| 5442 | enterRule(); | ||
| 3865 | 5443 | ||
| 3866 | } | 5444 | try { |
| 3867 | break; | 5445 | // InternalSolverLanguageParser.g:2135:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) ) |
| 5446 | // InternalSolverLanguageParser.g:2136:2: ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) | ||
| 5447 | { | ||
| 5448 | // InternalSolverLanguageParser.g:2136:2: ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) | ||
| 5449 | // InternalSolverLanguageParser.g:2137:3: ( ( ruleQualifiedName ) ) otherlv_1= Asterisk | ||
| 5450 | { | ||
| 5451 | // InternalSolverLanguageParser.g:2137:3: ( ( ruleQualifiedName ) ) | ||
| 5452 | // InternalSolverLanguageParser.g:2138:4: ( ruleQualifiedName ) | ||
| 5453 | { | ||
| 5454 | // InternalSolverLanguageParser.g:2138:4: ( ruleQualifiedName ) | ||
| 5455 | // InternalSolverLanguageParser.g:2139:5: ruleQualifiedName | ||
| 5456 | { | ||
| 3868 | 5457 | ||
| 3869 | default : | 5458 | if (current==null) { |
| 3870 | break loop18; | 5459 | current = createModelElement(grammarAccess.getTypedStarArgumentRule()); |
| 3871 | } | 5460 | } |
| 3872 | } while (true); | 5461 | |
| 3873 | 5462 | ||
| 5463 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
| 5464 | |||
| 5465 | pushFollow(FOLLOW_34); | ||
| 5466 | ruleQualifiedName(); | ||
| 3874 | 5467 | ||
| 3875 | } | 5468 | state._fsp--; |
| 3876 | break; | ||
| 3877 | 5469 | ||
| 3878 | } | ||
| 3879 | 5470 | ||
| 3880 | otherlv_6=(Token)match(input,19,FOLLOW_16); | 5471 | afterParserOrEnumRuleCall(); |
| 5472 | |||
| 3881 | 5473 | ||
| 3882 | newLeafNode(otherlv_6, grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); | 5474 | } |
| 3883 | |||
| 3884 | 5475 | ||
| 3885 | } | ||
| 3886 | break; | ||
| 3887 | 5476 | ||
| 3888 | } | 5477 | } |
| 3889 | 5478 | ||
| 3890 | otherlv_7=(Token)match(input,28,FOLLOW_17); | 5479 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); |
| 3891 | 5480 | ||
| 3892 | newLeafNode(otherlv_7, grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); | 5481 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
| 3893 | 5482 | ||
| 3894 | // InternalSolverLanguage.g:1321:3: (otherlv_8= 'false' | ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) ) | ||
| 3895 | int alt22=2; | ||
| 3896 | int LA22_0 = input.LA(1); | ||
| 3897 | 5483 | ||
| 3898 | if ( (LA22_0==14) ) { | ||
| 3899 | alt22=1; | ||
| 3900 | } | ||
| 3901 | else if ( (LA22_0==EOF||LA22_0==RULE_ID||(LA22_0>=11 && LA22_0<=13)||(LA22_0>=29 && LA22_0<=31)) ) { | ||
| 3902 | alt22=2; | ||
| 3903 | } | 5484 | } |
| 3904 | else { | ||
| 3905 | NoViableAltException nvae = | ||
| 3906 | new NoViableAltException("", 22, 0, input); | ||
| 3907 | |||
| 3908 | throw nvae; | ||
| 3909 | } | ||
| 3910 | switch (alt22) { | ||
| 3911 | case 1 : | ||
| 3912 | // InternalSolverLanguage.g:1322:4: otherlv_8= 'false' | ||
| 3913 | { | ||
| 3914 | otherlv_8=(Token)match(input,14,FOLLOW_5); | ||
| 3915 | |||
| 3916 | newLeafNode(otherlv_8, grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); | ||
| 3917 | |||
| 3918 | |||
| 3919 | } | ||
| 3920 | break; | ||
| 3921 | case 2 : | ||
| 3922 | // InternalSolverLanguage.g:1327:4: ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) | ||
| 3923 | { | ||
| 3924 | // InternalSolverLanguage.g:1327:4: ( ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* ) | ||
| 3925 | // InternalSolverLanguage.g:1328:5: ( (lv_bodies_9_0= rulePatternBody ) ) (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* | ||
| 3926 | { | ||
| 3927 | // InternalSolverLanguage.g:1328:5: ( (lv_bodies_9_0= rulePatternBody ) ) | ||
| 3928 | // InternalSolverLanguage.g:1329:6: (lv_bodies_9_0= rulePatternBody ) | ||
| 3929 | { | ||
| 3930 | // InternalSolverLanguage.g:1329:6: (lv_bodies_9_0= rulePatternBody ) | ||
| 3931 | // InternalSolverLanguage.g:1330:7: lv_bodies_9_0= rulePatternBody | ||
| 3932 | { | ||
| 3933 | 5485 | ||
| 3934 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); | ||
| 3935 | |||
| 3936 | pushFollow(FOLLOW_18); | ||
| 3937 | lv_bodies_9_0=rulePatternBody(); | ||
| 3938 | 5486 | ||
| 3939 | state._fsp--; | 5487 | } |
| 3940 | 5488 | ||
| 3941 | 5489 | ||
| 3942 | if (current==null) { | 5490 | leaveRule(); |
| 3943 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | ||
| 3944 | } | ||
| 3945 | add( | ||
| 3946 | current, | ||
| 3947 | "bodies", | ||
| 3948 | lv_bodies_9_0, | ||
| 3949 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | ||
| 3950 | afterParserOrEnumRuleCall(); | ||
| 3951 | |||
| 3952 | 5491 | ||
| 3953 | } | 5492 | } |
| 3954 | 5493 | ||
| 5494 | catch (RecognitionException re) { | ||
| 5495 | recover(input,re); | ||
| 5496 | appendSkippedTokens(); | ||
| 5497 | } | ||
| 5498 | finally { | ||
| 5499 | } | ||
| 5500 | return current; | ||
| 5501 | } | ||
| 5502 | // $ANTLR end "ruleTypedStarArgument" | ||
| 3955 | 5503 | ||
| 3956 | } | ||
| 3957 | 5504 | ||
| 3958 | // InternalSolverLanguage.g:1347:5: (otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) )* | 5505 | // $ANTLR start "entryRuleReference" |
| 3959 | loop21: | 5506 | // InternalSolverLanguageParser.g:2161:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; |
| 3960 | do { | 5507 | public final EObject entryRuleReference() throws RecognitionException { |
| 3961 | int alt21=2; | 5508 | EObject current = null; |
| 3962 | int LA21_0 = input.LA(1); | ||
| 3963 | 5509 | ||
| 3964 | if ( (LA21_0==29) ) { | 5510 | EObject iv_ruleReference = null; |
| 3965 | alt21=1; | ||
| 3966 | } | ||
| 3967 | 5511 | ||
| 3968 | 5512 | ||
| 3969 | switch (alt21) { | 5513 | try { |
| 3970 | case 1 : | 5514 | // InternalSolverLanguageParser.g:2161:50: (iv_ruleReference= ruleReference EOF ) |
| 3971 | // InternalSolverLanguage.g:1348:6: otherlv_10= '|' ( (lv_bodies_11_0= rulePatternBody ) ) | 5515 | // InternalSolverLanguageParser.g:2162:2: iv_ruleReference= ruleReference EOF |
| 3972 | { | 5516 | { |
| 3973 | otherlv_10=(Token)match(input,29,FOLLOW_19); | 5517 | newCompositeNode(grammarAccess.getReferenceRule()); |
| 5518 | pushFollow(FOLLOW_1); | ||
| 5519 | iv_ruleReference=ruleReference(); | ||
| 3974 | 5520 | ||
| 3975 | newLeafNode(otherlv_10, grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); | 5521 | state._fsp--; |
| 3976 | |||
| 3977 | // InternalSolverLanguage.g:1352:6: ( (lv_bodies_11_0= rulePatternBody ) ) | ||
| 3978 | // InternalSolverLanguage.g:1353:7: (lv_bodies_11_0= rulePatternBody ) | ||
| 3979 | { | ||
| 3980 | // InternalSolverLanguage.g:1353:7: (lv_bodies_11_0= rulePatternBody ) | ||
| 3981 | // InternalSolverLanguage.g:1354:8: lv_bodies_11_0= rulePatternBody | ||
| 3982 | { | ||
| 3983 | 5522 | ||
| 3984 | newCompositeNode(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); | 5523 | current =iv_ruleReference; |
| 3985 | 5524 | match(input,EOF,FOLLOW_2); | |
| 3986 | pushFollow(FOLLOW_18); | ||
| 3987 | lv_bodies_11_0=rulePatternBody(); | ||
| 3988 | 5525 | ||
| 3989 | state._fsp--; | 5526 | } |
| 3990 | 5527 | ||
| 5528 | } | ||
| 3991 | 5529 | ||
| 3992 | if (current==null) { | 5530 | catch (RecognitionException re) { |
| 3993 | current = createModelElementForParent(grammarAccess.getPredicateRule()); | 5531 | recover(input,re); |
| 3994 | } | 5532 | appendSkippedTokens(); |
| 3995 | add( | 5533 | } |
| 3996 | current, | 5534 | finally { |
| 3997 | "bodies", | 5535 | } |
| 3998 | lv_bodies_11_0, | 5536 | return current; |
| 3999 | "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | 5537 | } |
| 4000 | afterParserOrEnumRuleCall(); | 5538 | // $ANTLR end "entryRuleReference" |
| 4001 | |||
| 4002 | 5539 | ||
| 4003 | } | ||
| 4004 | 5540 | ||
| 5541 | // $ANTLR start "ruleReference" | ||
| 5542 | // InternalSolverLanguageParser.g:2168:1: ruleReference returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | ||
| 5543 | public final EObject ruleReference() throws RecognitionException { | ||
| 5544 | EObject current = null; | ||
| 4005 | 5545 | ||
| 4006 | } | ||
| 4007 | 5546 | ||
| 5547 | enterRule(); | ||
| 4008 | 5548 | ||
| 4009 | } | 5549 | try { |
| 4010 | break; | 5550 | // InternalSolverLanguageParser.g:2174:2: ( ( ( ruleQualifiedName ) ) ) |
| 5551 | // InternalSolverLanguageParser.g:2175:2: ( ( ruleQualifiedName ) ) | ||
| 5552 | { | ||
| 5553 | // InternalSolverLanguageParser.g:2175:2: ( ( ruleQualifiedName ) ) | ||
| 5554 | // InternalSolverLanguageParser.g:2176:3: ( ruleQualifiedName ) | ||
| 5555 | { | ||
| 5556 | // InternalSolverLanguageParser.g:2176:3: ( ruleQualifiedName ) | ||
| 5557 | // InternalSolverLanguageParser.g:2177:4: ruleQualifiedName | ||
| 5558 | { | ||
| 4011 | 5559 | ||
| 4012 | default : | 5560 | if (current==null) { |
| 4013 | break loop21; | 5561 | current = createModelElement(grammarAccess.getReferenceRule()); |
| 4014 | } | 5562 | } |
| 4015 | } while (true); | 5563 | |
| 4016 | 5564 | ||
| 5565 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | ||
| 5566 | |||
| 5567 | pushFollow(FOLLOW_2); | ||
| 5568 | ruleQualifiedName(); | ||
| 4017 | 5569 | ||
| 4018 | } | 5570 | state._fsp--; |
| 4019 | 5571 | ||
| 4020 | 5572 | ||
| 4021 | } | 5573 | afterParserOrEnumRuleCall(); |
| 4022 | break; | 5574 | |
| 4023 | 5575 | ||
| 4024 | } | 5576 | } |
| 4025 | 5577 | ||
| 4026 | otherlv_12=(Token)match(input,12,FOLLOW_2); | ||
| 4027 | |||
| 4028 | newLeafNode(otherlv_12, grammarAccess.getPredicateAccess().getFullStopKeyword_5()); | ||
| 4029 | |||
| 4030 | 5578 | ||
| 4031 | } | 5579 | } |
| 4032 | 5580 | ||
| @@ -4046,28 +5594,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4046 | } | 5594 | } |
| 4047 | return current; | 5595 | return current; |
| 4048 | } | 5596 | } |
| 4049 | // $ANTLR end "rulePredicate" | 5597 | // $ANTLR end "ruleReference" |
| 4050 | 5598 | ||
| 4051 | 5599 | ||
| 4052 | // $ANTLR start "entryRuleParameter" | 5600 | // $ANTLR start "entryRuleInterval" |
| 4053 | // InternalSolverLanguage.g:1382:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; | 5601 | // InternalSolverLanguageParser.g:2194:1: entryRuleInterval returns [EObject current=null] : iv_ruleInterval= ruleInterval EOF ; |
| 4054 | public final EObject entryRuleParameter() throws RecognitionException { | 5602 | public final EObject entryRuleInterval() throws RecognitionException { |
| 4055 | EObject current = null; | 5603 | EObject current = null; |
| 4056 | 5604 | ||
| 4057 | EObject iv_ruleParameter = null; | 5605 | EObject iv_ruleInterval = null; |
| 4058 | 5606 | ||
| 4059 | 5607 | ||
| 4060 | try { | 5608 | try { |
| 4061 | // InternalSolverLanguage.g:1382:50: (iv_ruleParameter= ruleParameter EOF ) | 5609 | // InternalSolverLanguageParser.g:2194:49: (iv_ruleInterval= ruleInterval EOF ) |
| 4062 | // InternalSolverLanguage.g:1383:2: iv_ruleParameter= ruleParameter EOF | 5610 | // InternalSolverLanguageParser.g:2195:2: iv_ruleInterval= ruleInterval EOF |
| 4063 | { | 5611 | { |
| 4064 | newCompositeNode(grammarAccess.getParameterRule()); | 5612 | newCompositeNode(grammarAccess.getIntervalRule()); |
| 4065 | pushFollow(FOLLOW_1); | 5613 | pushFollow(FOLLOW_1); |
| 4066 | iv_ruleParameter=ruleParameter(); | 5614 | iv_ruleInterval=ruleInterval(); |
| 4067 | 5615 | ||
| 4068 | state._fsp--; | 5616 | state._fsp--; |
| 4069 | 5617 | ||
| 4070 | current =iv_ruleParameter; | 5618 | current =iv_ruleInterval; |
| 4071 | match(input,EOF,FOLLOW_2); | 5619 | match(input,EOF,FOLLOW_2); |
| 4072 | 5620 | ||
| 4073 | } | 5621 | } |
| @@ -4082,53 +5630,59 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4082 | } | 5630 | } |
| 4083 | return current; | 5631 | return current; |
| 4084 | } | 5632 | } |
| 4085 | // $ANTLR end "entryRuleParameter" | 5633 | // $ANTLR end "entryRuleInterval" |
| 4086 | 5634 | ||
| 4087 | 5635 | ||
| 4088 | // $ANTLR start "ruleParameter" | 5636 | // $ANTLR start "ruleInterval" |
| 4089 | // InternalSolverLanguage.g:1389:1: ruleParameter returns [EObject current=null] : ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ; | 5637 | // InternalSolverLanguageParser.g:2201:1: ruleInterval returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) ; |
| 4090 | public final EObject ruleParameter() throws RecognitionException { | 5638 | public final EObject ruleInterval() throws RecognitionException { |
| 4091 | EObject current = null; | 5639 | EObject current = null; |
| 4092 | 5640 | ||
| 4093 | Token otherlv_1=null; | 5641 | Token otherlv_0=null; |
| 4094 | EObject lv_variable_0_0 = null; | 5642 | Token otherlv_2=null; |
| 5643 | Token otherlv_4=null; | ||
| 5644 | EObject lv_lowerBound_1_0 = null; | ||
| 4095 | 5645 | ||
| 4096 | EObject lv_type_2_0 = null; | 5646 | EObject lv_upperBound_3_0 = null; |
| 4097 | 5647 | ||
| 4098 | 5648 | ||
| 4099 | 5649 | ||
| 4100 | enterRule(); | 5650 | enterRule(); |
| 4101 | 5651 | ||
| 4102 | try { | 5652 | try { |
| 4103 | // InternalSolverLanguage.g:1395:2: ( ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ) | 5653 | // InternalSolverLanguageParser.g:2207:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) ) |
| 4104 | // InternalSolverLanguage.g:1396:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) | 5654 | // InternalSolverLanguageParser.g:2208:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) |
| 4105 | { | 5655 | { |
| 4106 | // InternalSolverLanguage.g:1396:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) | 5656 | // InternalSolverLanguageParser.g:2208:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) |
| 4107 | // InternalSolverLanguage.g:1397:3: ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? | 5657 | // InternalSolverLanguageParser.g:2209:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket |
| 4108 | { | 5658 | { |
| 4109 | // InternalSolverLanguage.g:1397:3: ( (lv_variable_0_0= ruleVariable ) ) | 5659 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_6); |
| 4110 | // InternalSolverLanguage.g:1398:4: (lv_variable_0_0= ruleVariable ) | 5660 | |
| 5661 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
| 5662 | |||
| 5663 | // InternalSolverLanguageParser.g:2213:3: ( (lv_lowerBound_1_0= ruleExpression ) ) | ||
| 5664 | // InternalSolverLanguageParser.g:2214:4: (lv_lowerBound_1_0= ruleExpression ) | ||
| 4111 | { | 5665 | { |
| 4112 | // InternalSolverLanguage.g:1398:4: (lv_variable_0_0= ruleVariable ) | 5666 | // InternalSolverLanguageParser.g:2214:4: (lv_lowerBound_1_0= ruleExpression ) |
| 4113 | // InternalSolverLanguage.g:1399:5: lv_variable_0_0= ruleVariable | 5667 | // InternalSolverLanguageParser.g:2215:5: lv_lowerBound_1_0= ruleExpression |
| 4114 | { | 5668 | { |
| 4115 | 5669 | ||
| 4116 | newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); | 5670 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); |
| 4117 | 5671 | ||
| 4118 | pushFollow(FOLLOW_20); | 5672 | pushFollow(FOLLOW_35); |
| 4119 | lv_variable_0_0=ruleVariable(); | 5673 | lv_lowerBound_1_0=ruleExpression(); |
| 4120 | 5674 | ||
| 4121 | state._fsp--; | 5675 | state._fsp--; |
| 4122 | 5676 | ||
| 4123 | 5677 | ||
| 4124 | if (current==null) { | 5678 | if (current==null) { |
| 4125 | current = createModelElementForParent(grammarAccess.getParameterRule()); | 5679 | current = createModelElementForParent(grammarAccess.getIntervalRule()); |
| 4126 | } | 5680 | } |
| 4127 | set( | 5681 | set( |
| 4128 | current, | 5682 | current, |
| 4129 | "variable", | 5683 | "lowerBound", |
| 4130 | lv_variable_0_0, | 5684 | lv_lowerBound_1_0, |
| 4131 | "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | 5685 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
| 4132 | afterParserOrEnumRuleCall(); | 5686 | afterParserOrEnumRuleCall(); |
| 4133 | 5687 | ||
| 4134 | 5688 | ||
| @@ -4137,58 +5691,45 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4137 | 5691 | ||
| 4138 | } | 5692 | } |
| 4139 | 5693 | ||
| 4140 | // InternalSolverLanguage.g:1416:3: (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? | 5694 | otherlv_2=(Token)match(input,FullStopFullStop,FOLLOW_6); |
| 4141 | int alt23=2; | ||
| 4142 | int LA23_0 = input.LA(1); | ||
| 4143 | |||
| 4144 | if ( (LA23_0==20) ) { | ||
| 4145 | alt23=1; | ||
| 4146 | } | ||
| 4147 | switch (alt23) { | ||
| 4148 | case 1 : | ||
| 4149 | // InternalSolverLanguage.g:1417:4: otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) | ||
| 4150 | { | ||
| 4151 | otherlv_1=(Token)match(input,20,FOLLOW_21); | ||
| 4152 | |||
| 4153 | newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); | ||
| 4154 | |||
| 4155 | // InternalSolverLanguage.g:1421:4: ( (lv_type_2_0= ruleSymbol ) ) | ||
| 4156 | // InternalSolverLanguage.g:1422:5: (lv_type_2_0= ruleSymbol ) | ||
| 4157 | { | ||
| 4158 | // InternalSolverLanguage.g:1422:5: (lv_type_2_0= ruleSymbol ) | ||
| 4159 | // InternalSolverLanguage.g:1423:6: lv_type_2_0= ruleSymbol | ||
| 4160 | { | ||
| 4161 | |||
| 4162 | newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); | ||
| 4163 | |||
| 4164 | pushFollow(FOLLOW_2); | ||
| 4165 | lv_type_2_0=ruleSymbol(); | ||
| 4166 | |||
| 4167 | state._fsp--; | ||
| 4168 | 5695 | ||
| 5696 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | ||
| 5697 | |||
| 5698 | // InternalSolverLanguageParser.g:2236:3: ( (lv_upperBound_3_0= ruleExpression ) ) | ||
| 5699 | // InternalSolverLanguageParser.g:2237:4: (lv_upperBound_3_0= ruleExpression ) | ||
| 5700 | { | ||
| 5701 | // InternalSolverLanguageParser.g:2237:4: (lv_upperBound_3_0= ruleExpression ) | ||
| 5702 | // InternalSolverLanguageParser.g:2238:5: lv_upperBound_3_0= ruleExpression | ||
| 5703 | { | ||
| 4169 | 5704 | ||
| 4170 | if (current==null) { | 5705 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); |
| 4171 | current = createModelElementForParent(grammarAccess.getParameterRule()); | 5706 | |
| 4172 | } | 5707 | pushFollow(FOLLOW_36); |
| 4173 | set( | 5708 | lv_upperBound_3_0=ruleExpression(); |
| 4174 | current, | ||
| 4175 | "type", | ||
| 4176 | lv_type_2_0, | ||
| 4177 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 4178 | afterParserOrEnumRuleCall(); | ||
| 4179 | |||
| 4180 | 5709 | ||
| 4181 | } | 5710 | state._fsp--; |
| 4182 | 5711 | ||
| 4183 | 5712 | ||
| 4184 | } | 5713 | if (current==null) { |
| 5714 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
| 5715 | } | ||
| 5716 | set( | ||
| 5717 | current, | ||
| 5718 | "upperBound", | ||
| 5719 | lv_upperBound_3_0, | ||
| 5720 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 5721 | afterParserOrEnumRuleCall(); | ||
| 5722 | |||
| 4185 | 5723 | ||
| 5724 | } | ||
| 4186 | 5725 | ||
| 4187 | } | ||
| 4188 | break; | ||
| 4189 | 5726 | ||
| 4190 | } | 5727 | } |
| 4191 | 5728 | ||
| 5729 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
| 5730 | |||
| 5731 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
| 5732 | |||
| 4192 | 5733 | ||
| 4193 | } | 5734 | } |
| 4194 | 5735 | ||
| @@ -4208,28 +5749,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4208 | } | 5749 | } |
| 4209 | return current; | 5750 | return current; |
| 4210 | } | 5751 | } |
| 4211 | // $ANTLR end "ruleParameter" | 5752 | // $ANTLR end "ruleInterval" |
| 4212 | 5753 | ||
| 4213 | 5754 | ||
| 4214 | // $ANTLR start "entryRulePatternBody" | 5755 | // $ANTLR start "entryRuleLiteral" |
| 4215 | // InternalSolverLanguage.g:1445:1: entryRulePatternBody returns [EObject current=null] : iv_rulePatternBody= rulePatternBody EOF ; | 5756 | // InternalSolverLanguageParser.g:2263:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; |
| 4216 | public final EObject entryRulePatternBody() throws RecognitionException { | 5757 | public final EObject entryRuleLiteral() throws RecognitionException { |
| 4217 | EObject current = null; | 5758 | EObject current = null; |
| 4218 | 5759 | ||
| 4219 | EObject iv_rulePatternBody = null; | 5760 | EObject iv_ruleLiteral = null; |
| 4220 | 5761 | ||
| 4221 | 5762 | ||
| 4222 | try { | 5763 | try { |
| 4223 | // InternalSolverLanguage.g:1445:52: (iv_rulePatternBody= rulePatternBody EOF ) | 5764 | // InternalSolverLanguageParser.g:2263:48: (iv_ruleLiteral= ruleLiteral EOF ) |
| 4224 | // InternalSolverLanguage.g:1446:2: iv_rulePatternBody= rulePatternBody EOF | 5765 | // InternalSolverLanguageParser.g:2264:2: iv_ruleLiteral= ruleLiteral EOF |
| 4225 | { | 5766 | { |
| 4226 | newCompositeNode(grammarAccess.getPatternBodyRule()); | 5767 | newCompositeNode(grammarAccess.getLiteralRule()); |
| 4227 | pushFollow(FOLLOW_1); | 5768 | pushFollow(FOLLOW_1); |
| 4228 | iv_rulePatternBody=rulePatternBody(); | 5769 | iv_ruleLiteral=ruleLiteral(); |
| 4229 | 5770 | ||
| 4230 | state._fsp--; | 5771 | state._fsp--; |
| 4231 | 5772 | ||
| 4232 | current =iv_rulePatternBody; | 5773 | current =iv_ruleLiteral; |
| 4233 | match(input,EOF,FOLLOW_2); | 5774 | match(input,EOF,FOLLOW_2); |
| 4234 | 5775 | ||
| 4235 | } | 5776 | } |
| @@ -4244,125 +5785,162 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4244 | } | 5785 | } |
| 4245 | return current; | 5786 | return current; |
| 4246 | } | 5787 | } |
| 4247 | // $ANTLR end "entryRulePatternBody" | 5788 | // $ANTLR end "entryRuleLiteral" |
| 4248 | 5789 | ||
| 4249 | 5790 | ||
| 4250 | // $ANTLR start "rulePatternBody" | 5791 | // $ANTLR start "ruleLiteral" |
| 4251 | // InternalSolverLanguage.g:1452:1: rulePatternBody returns [EObject current=null] : ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ; | 5792 | // InternalSolverLanguageParser.g:2270:1: ruleLiteral returns [EObject current=null] : (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ; |
| 4252 | public final EObject rulePatternBody() throws RecognitionException { | 5793 | public final EObject ruleLiteral() throws RecognitionException { |
| 4253 | EObject current = null; | 5794 | EObject current = null; |
| 4254 | 5795 | ||
| 4255 | Token otherlv_1=null; | 5796 | EObject this_LogicLiteral_0 = null; |
| 4256 | EObject lv_constraints_2_0 = null; | ||
| 4257 | 5797 | ||
| 5798 | EObject this_NumericLiteral_1 = null; | ||
| 4258 | 5799 | ||
| 5800 | EObject this_InfinityLiteral_2 = null; | ||
| 4259 | 5801 | ||
| 4260 | enterRule(); | 5802 | EObject this_EmptyIntervalLiteral_3 = null; |
| 4261 | 5803 | ||
| 4262 | try { | 5804 | EObject this_StringLiteral_4 = null; |
| 4263 | // InternalSolverLanguage.g:1458:2: ( ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ) | ||
| 4264 | // InternalSolverLanguage.g:1459:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) | ||
| 4265 | { | ||
| 4266 | // InternalSolverLanguage.g:1459:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) | ||
| 4267 | // InternalSolverLanguage.g:1460:3: () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) | ||
| 4268 | { | ||
| 4269 | // InternalSolverLanguage.g:1460:3: () | ||
| 4270 | // InternalSolverLanguage.g:1461:4: | ||
| 4271 | { | ||
| 4272 | 5805 | ||
| 4273 | current = forceCreateModelElement( | ||
| 4274 | grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), | ||
| 4275 | current); | ||
| 4276 | |||
| 4277 | 5806 | ||
| 4278 | } | ||
| 4279 | 5807 | ||
| 4280 | // InternalSolverLanguage.g:1467:3: (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) | 5808 | enterRule(); |
| 4281 | int alt25=2; | ||
| 4282 | int LA25_0 = input.LA(1); | ||
| 4283 | 5809 | ||
| 4284 | if ( (LA25_0==13) ) { | 5810 | try { |
| 5811 | // InternalSolverLanguageParser.g:2276:2: ( (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ) | ||
| 5812 | // InternalSolverLanguageParser.g:2277:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) | ||
| 5813 | { | ||
| 5814 | // InternalSolverLanguageParser.g:2277:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) | ||
| 5815 | int alt25=5; | ||
| 5816 | switch ( input.LA(1) ) { | ||
| 5817 | case Unknown: | ||
| 5818 | case Error: | ||
| 5819 | case False: | ||
| 5820 | case True: | ||
| 5821 | { | ||
| 4285 | alt25=1; | 5822 | alt25=1; |
| 4286 | } | 5823 | } |
| 4287 | else if ( (LA25_0==EOF||LA25_0==RULE_ID||(LA25_0>=11 && LA25_0<=12)||(LA25_0>=29 && LA25_0<=31)) ) { | 5824 | break; |
| 5825 | case RULE_INT: | ||
| 5826 | { | ||
| 4288 | alt25=2; | 5827 | alt25=2; |
| 4289 | } | 5828 | } |
| 4290 | else { | 5829 | break; |
| 5830 | case Inf: | ||
| 5831 | { | ||
| 5832 | alt25=3; | ||
| 5833 | } | ||
| 5834 | break; | ||
| 5835 | case Empty: | ||
| 5836 | { | ||
| 5837 | alt25=4; | ||
| 5838 | } | ||
| 5839 | break; | ||
| 5840 | case RULE_STRING: | ||
| 5841 | { | ||
| 5842 | alt25=5; | ||
| 5843 | } | ||
| 5844 | break; | ||
| 5845 | default: | ||
| 4291 | NoViableAltException nvae = | 5846 | NoViableAltException nvae = |
| 4292 | new NoViableAltException("", 25, 0, input); | 5847 | new NoViableAltException("", 25, 0, input); |
| 4293 | 5848 | ||
| 4294 | throw nvae; | 5849 | throw nvae; |
| 4295 | } | 5850 | } |
| 5851 | |||
| 4296 | switch (alt25) { | 5852 | switch (alt25) { |
| 4297 | case 1 : | 5853 | case 1 : |
| 4298 | // InternalSolverLanguage.g:1468:4: otherlv_1= 'true' | 5854 | // InternalSolverLanguageParser.g:2278:3: this_LogicLiteral_0= ruleLogicLiteral |
| 4299 | { | 5855 | { |
| 4300 | otherlv_1=(Token)match(input,13,FOLLOW_2); | ||
| 4301 | 5856 | ||
| 4302 | newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | 5857 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); |
| 4303 | 5858 | ||
| 5859 | pushFollow(FOLLOW_2); | ||
| 5860 | this_LogicLiteral_0=ruleLogicLiteral(); | ||
| 5861 | |||
| 5862 | state._fsp--; | ||
| 5863 | |||
| 5864 | |||
| 5865 | current = this_LogicLiteral_0; | ||
| 5866 | afterParserOrEnumRuleCall(); | ||
| 5867 | |||
| 4304 | 5868 | ||
| 4305 | } | 5869 | } |
| 4306 | break; | 5870 | break; |
| 4307 | case 2 : | 5871 | case 2 : |
| 4308 | // InternalSolverLanguage.g:1473:4: ( (lv_constraints_2_0= ruleConstraint ) )* | 5872 | // InternalSolverLanguageParser.g:2287:3: this_NumericLiteral_1= ruleNumericLiteral |
| 4309 | { | 5873 | { |
| 4310 | // InternalSolverLanguage.g:1473:4: ( (lv_constraints_2_0= ruleConstraint ) )* | ||
| 4311 | loop24: | ||
| 4312 | do { | ||
| 4313 | int alt24=2; | ||
| 4314 | int LA24_0 = input.LA(1); | ||
| 4315 | 5874 | ||
| 4316 | if ( (LA24_0==RULE_ID||LA24_0==11||(LA24_0>=30 && LA24_0<=31)) ) { | 5875 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); |
| 4317 | alt24=1; | 5876 | |
| 4318 | } | 5877 | pushFollow(FOLLOW_2); |
| 5878 | this_NumericLiteral_1=ruleNumericLiteral(); | ||
| 4319 | 5879 | ||
| 5880 | state._fsp--; | ||
| 4320 | 5881 | ||
| 4321 | switch (alt24) { | ||
| 4322 | case 1 : | ||
| 4323 | // InternalSolverLanguage.g:1474:5: (lv_constraints_2_0= ruleConstraint ) | ||
| 4324 | { | ||
| 4325 | // InternalSolverLanguage.g:1474:5: (lv_constraints_2_0= ruleConstraint ) | ||
| 4326 | // InternalSolverLanguage.g:1475:6: lv_constraints_2_0= ruleConstraint | ||
| 4327 | { | ||
| 4328 | 5882 | ||
| 4329 | newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); | 5883 | current = this_NumericLiteral_1; |
| 4330 | 5884 | afterParserOrEnumRuleCall(); | |
| 4331 | pushFollow(FOLLOW_22); | 5885 | |
| 4332 | lv_constraints_2_0=ruleConstraint(); | ||
| 4333 | 5886 | ||
| 4334 | state._fsp--; | 5887 | } |
| 5888 | break; | ||
| 5889 | case 3 : | ||
| 5890 | // InternalSolverLanguageParser.g:2296:3: this_InfinityLiteral_2= ruleInfinityLiteral | ||
| 5891 | { | ||
| 4335 | 5892 | ||
| 5893 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | ||
| 5894 | |||
| 5895 | pushFollow(FOLLOW_2); | ||
| 5896 | this_InfinityLiteral_2=ruleInfinityLiteral(); | ||
| 4336 | 5897 | ||
| 4337 | if (current==null) { | 5898 | state._fsp--; |
| 4338 | current = createModelElementForParent(grammarAccess.getPatternBodyRule()); | ||
| 4339 | } | ||
| 4340 | add( | ||
| 4341 | current, | ||
| 4342 | "constraints", | ||
| 4343 | lv_constraints_2_0, | ||
| 4344 | "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | ||
| 4345 | afterParserOrEnumRuleCall(); | ||
| 4346 | |||
| 4347 | 5899 | ||
| 4348 | } | ||
| 4349 | 5900 | ||
| 5901 | current = this_InfinityLiteral_2; | ||
| 5902 | afterParserOrEnumRuleCall(); | ||
| 5903 | |||
| 4350 | 5904 | ||
| 4351 | } | 5905 | } |
| 4352 | break; | 5906 | break; |
| 5907 | case 4 : | ||
| 5908 | // InternalSolverLanguageParser.g:2305:3: this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | ||
| 5909 | { | ||
| 4353 | 5910 | ||
| 4354 | default : | 5911 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
| 4355 | break loop24; | 5912 | |
| 4356 | } | 5913 | pushFollow(FOLLOW_2); |
| 4357 | } while (true); | 5914 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral(); |
| 4358 | 5915 | ||
| 5916 | state._fsp--; | ||
| 5917 | |||
| 5918 | |||
| 5919 | current = this_EmptyIntervalLiteral_3; | ||
| 5920 | afterParserOrEnumRuleCall(); | ||
| 5921 | |||
| 4359 | 5922 | ||
| 4360 | } | 5923 | } |
| 4361 | break; | 5924 | break; |
| 5925 | case 5 : | ||
| 5926 | // InternalSolverLanguageParser.g:2314:3: this_StringLiteral_4= ruleStringLiteral | ||
| 5927 | { | ||
| 4362 | 5928 | ||
| 4363 | } | 5929 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
| 5930 | |||
| 5931 | pushFollow(FOLLOW_2); | ||
| 5932 | this_StringLiteral_4=ruleStringLiteral(); | ||
| 5933 | |||
| 5934 | state._fsp--; | ||
| 4364 | 5935 | ||
| 4365 | 5936 | ||
| 5937 | current = this_StringLiteral_4; | ||
| 5938 | afterParserOrEnumRuleCall(); | ||
| 5939 | |||
| 5940 | |||
| 5941 | } | ||
| 5942 | break; | ||
| 5943 | |||
| 4366 | } | 5944 | } |
| 4367 | 5945 | ||
| 4368 | 5946 | ||
| @@ -4381,28 +5959,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4381 | } | 5959 | } |
| 4382 | return current; | 5960 | return current; |
| 4383 | } | 5961 | } |
| 4384 | // $ANTLR end "rulePatternBody" | 5962 | // $ANTLR end "ruleLiteral" |
| 4385 | 5963 | ||
| 4386 | 5964 | ||
| 4387 | // $ANTLR start "entryRulePolarity" | 5965 | // $ANTLR start "entryRuleLogicLiteral" |
| 4388 | // InternalSolverLanguage.g:1497:1: entryRulePolarity returns [EObject current=null] : iv_rulePolarity= rulePolarity EOF ; | 5966 | // InternalSolverLanguageParser.g:2326:1: entryRuleLogicLiteral returns [EObject current=null] : iv_ruleLogicLiteral= ruleLogicLiteral EOF ; |
| 4389 | public final EObject entryRulePolarity() throws RecognitionException { | 5967 | public final EObject entryRuleLogicLiteral() throws RecognitionException { |
| 4390 | EObject current = null; | 5968 | EObject current = null; |
| 4391 | 5969 | ||
| 4392 | EObject iv_rulePolarity = null; | 5970 | EObject iv_ruleLogicLiteral = null; |
| 4393 | 5971 | ||
| 4394 | 5972 | ||
| 4395 | try { | 5973 | try { |
| 4396 | // InternalSolverLanguage.g:1497:49: (iv_rulePolarity= rulePolarity EOF ) | 5974 | // InternalSolverLanguageParser.g:2326:53: (iv_ruleLogicLiteral= ruleLogicLiteral EOF ) |
| 4397 | // InternalSolverLanguage.g:1498:2: iv_rulePolarity= rulePolarity EOF | 5975 | // InternalSolverLanguageParser.g:2327:2: iv_ruleLogicLiteral= ruleLogicLiteral EOF |
| 4398 | { | 5976 | { |
| 4399 | newCompositeNode(grammarAccess.getPolarityRule()); | 5977 | newCompositeNode(grammarAccess.getLogicLiteralRule()); |
| 4400 | pushFollow(FOLLOW_1); | 5978 | pushFollow(FOLLOW_1); |
| 4401 | iv_rulePolarity=rulePolarity(); | 5979 | iv_ruleLogicLiteral=ruleLogicLiteral(); |
| 4402 | 5980 | ||
| 4403 | state._fsp--; | 5981 | state._fsp--; |
| 4404 | 5982 | ||
| 4405 | current =iv_rulePolarity; | 5983 | current =iv_ruleLogicLiteral; |
| 4406 | match(input,EOF,FOLLOW_2); | 5984 | match(input,EOF,FOLLOW_2); |
| 4407 | 5985 | ||
| 4408 | } | 5986 | } |
| @@ -4417,95 +5995,153 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4417 | } | 5995 | } |
| 4418 | return current; | 5996 | return current; |
| 4419 | } | 5997 | } |
| 4420 | // $ANTLR end "entryRulePolarity" | 5998 | // $ANTLR end "entryRuleLogicLiteral" |
| 4421 | 5999 | ||
| 4422 | 6000 | ||
| 4423 | // $ANTLR start "rulePolarity" | 6001 | // $ANTLR start "ruleLogicLiteral" |
| 4424 | // InternalSolverLanguage.g:1504:1: rulePolarity returns [EObject current=null] : ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ; | 6002 | // InternalSolverLanguageParser.g:2333:1: ruleLogicLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleLogicValue ) ) ; |
| 4425 | public final EObject rulePolarity() throws RecognitionException { | 6003 | public final EObject ruleLogicLiteral() throws RecognitionException { |
| 4426 | EObject current = null; | 6004 | EObject current = null; |
| 4427 | 6005 | ||
| 4428 | Token otherlv_1=null; | 6006 | Enumerator lv_value_0_0 = null; |
| 4429 | Token otherlv_3=null; | 6007 | |
| 4430 | 6008 | ||
| 4431 | 6009 | ||
| 4432 | enterRule(); | 6010 | enterRule(); |
| 4433 | 6011 | ||
| 4434 | try { | 6012 | try { |
| 4435 | // InternalSolverLanguage.g:1510:2: ( ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ) | 6013 | // InternalSolverLanguageParser.g:2339:2: ( ( (lv_value_0_0= ruleLogicValue ) ) ) |
| 4436 | // InternalSolverLanguage.g:1511:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) | 6014 | // InternalSolverLanguageParser.g:2340:2: ( (lv_value_0_0= ruleLogicValue ) ) |
| 6015 | { | ||
| 6016 | // InternalSolverLanguageParser.g:2340:2: ( (lv_value_0_0= ruleLogicValue ) ) | ||
| 6017 | // InternalSolverLanguageParser.g:2341:3: (lv_value_0_0= ruleLogicValue ) | ||
| 6018 | { | ||
| 6019 | // InternalSolverLanguageParser.g:2341:3: (lv_value_0_0= ruleLogicValue ) | ||
| 6020 | // InternalSolverLanguageParser.g:2342:4: lv_value_0_0= ruleLogicValue | ||
| 4437 | { | 6021 | { |
| 4438 | // InternalSolverLanguage.g:1511:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) | ||
| 4439 | int alt26=2; | ||
| 4440 | int LA26_0 = input.LA(1); | ||
| 4441 | 6022 | ||
| 4442 | if ( (LA26_0==30) ) { | 6023 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
| 4443 | alt26=1; | 6024 | |
| 6025 | pushFollow(FOLLOW_2); | ||
| 6026 | lv_value_0_0=ruleLogicValue(); | ||
| 6027 | |||
| 6028 | state._fsp--; | ||
| 6029 | |||
| 6030 | |||
| 6031 | if (current==null) { | ||
| 6032 | current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | ||
| 6033 | } | ||
| 6034 | set( | ||
| 6035 | current, | ||
| 6036 | "value", | ||
| 6037 | lv_value_0_0, | ||
| 6038 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
| 6039 | afterParserOrEnumRuleCall(); | ||
| 6040 | |||
| 6041 | |||
| 4444 | } | 6042 | } |
| 4445 | else if ( (LA26_0==11) ) { | 6043 | |
| 4446 | alt26=2; | 6044 | |
| 4447 | } | 6045 | } |
| 4448 | else { | ||
| 4449 | NoViableAltException nvae = | ||
| 4450 | new NoViableAltException("", 26, 0, input); | ||
| 4451 | 6046 | ||
| 4452 | throw nvae; | 6047 | |
| 4453 | } | 6048 | } |
| 4454 | switch (alt26) { | ||
| 4455 | case 1 : | ||
| 4456 | // InternalSolverLanguage.g:1512:3: ( () otherlv_1= '+' ) | ||
| 4457 | { | ||
| 4458 | // InternalSolverLanguage.g:1512:3: ( () otherlv_1= '+' ) | ||
| 4459 | // InternalSolverLanguage.g:1513:4: () otherlv_1= '+' | ||
| 4460 | { | ||
| 4461 | // InternalSolverLanguage.g:1513:4: () | ||
| 4462 | // InternalSolverLanguage.g:1514:5: | ||
| 4463 | { | ||
| 4464 | 6049 | ||
| 4465 | current = forceCreateModelElement( | ||
| 4466 | grammarAccess.getPolarityAccess().getPositiveAction_0_0(), | ||
| 4467 | current); | ||
| 4468 | |||
| 4469 | 6050 | ||
| 4470 | } | 6051 | leaveRule(); |
| 4471 | 6052 | ||
| 4472 | otherlv_1=(Token)match(input,30,FOLLOW_2); | 6053 | } |
| 4473 | 6054 | ||
| 4474 | newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); | 6055 | catch (RecognitionException re) { |
| 4475 | 6056 | recover(input,re); | |
| 6057 | appendSkippedTokens(); | ||
| 6058 | } | ||
| 6059 | finally { | ||
| 6060 | } | ||
| 6061 | return current; | ||
| 6062 | } | ||
| 6063 | // $ANTLR end "ruleLogicLiteral" | ||
| 4476 | 6064 | ||
| 4477 | } | ||
| 4478 | 6065 | ||
| 6066 | // $ANTLR start "entryRuleNumericLiteral" | ||
| 6067 | // InternalSolverLanguageParser.g:2362:1: entryRuleNumericLiteral returns [EObject current=null] : iv_ruleNumericLiteral= ruleNumericLiteral EOF ; | ||
| 6068 | public final EObject entryRuleNumericLiteral() throws RecognitionException { | ||
| 6069 | EObject current = null; | ||
| 4479 | 6070 | ||
| 4480 | } | 6071 | EObject iv_ruleNumericLiteral = null; |
| 4481 | break; | ||
| 4482 | case 2 : | ||
| 4483 | // InternalSolverLanguage.g:1526:3: ( () otherlv_3= '-' ) | ||
| 4484 | { | ||
| 4485 | // InternalSolverLanguage.g:1526:3: ( () otherlv_3= '-' ) | ||
| 4486 | // InternalSolverLanguage.g:1527:4: () otherlv_3= '-' | ||
| 4487 | { | ||
| 4488 | // InternalSolverLanguage.g:1527:4: () | ||
| 4489 | // InternalSolverLanguage.g:1528:5: | ||
| 4490 | { | ||
| 4491 | 6072 | ||
| 4492 | current = forceCreateModelElement( | ||
| 4493 | grammarAccess.getPolarityAccess().getNegativeAction_1_0(), | ||
| 4494 | current); | ||
| 4495 | |||
| 4496 | 6073 | ||
| 4497 | } | 6074 | try { |
| 6075 | // InternalSolverLanguageParser.g:2362:55: (iv_ruleNumericLiteral= ruleNumericLiteral EOF ) | ||
| 6076 | // InternalSolverLanguageParser.g:2363:2: iv_ruleNumericLiteral= ruleNumericLiteral EOF | ||
| 6077 | { | ||
| 6078 | newCompositeNode(grammarAccess.getNumericLiteralRule()); | ||
| 6079 | pushFollow(FOLLOW_1); | ||
| 6080 | iv_ruleNumericLiteral=ruleNumericLiteral(); | ||
| 4498 | 6081 | ||
| 4499 | otherlv_3=(Token)match(input,11,FOLLOW_2); | 6082 | state._fsp--; |
| 4500 | 6083 | ||
| 4501 | newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); | 6084 | current =iv_ruleNumericLiteral; |
| 4502 | 6085 | match(input,EOF,FOLLOW_2); | |
| 4503 | 6086 | ||
| 4504 | } | 6087 | } |
| 4505 | 6088 | ||
| 6089 | } | ||
| 6090 | |||
| 6091 | catch (RecognitionException re) { | ||
| 6092 | recover(input,re); | ||
| 6093 | appendSkippedTokens(); | ||
| 6094 | } | ||
| 6095 | finally { | ||
| 6096 | } | ||
| 6097 | return current; | ||
| 6098 | } | ||
| 6099 | // $ANTLR end "entryRuleNumericLiteral" | ||
| 6100 | |||
| 6101 | |||
| 6102 | // $ANTLR start "ruleNumericLiteral" | ||
| 6103 | // InternalSolverLanguageParser.g:2369:1: ruleNumericLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleReal ) ) ; | ||
| 6104 | public final EObject ruleNumericLiteral() throws RecognitionException { | ||
| 6105 | EObject current = null; | ||
| 6106 | |||
| 6107 | AntlrDatatypeRuleToken lv_value_0_0 = null; | ||
| 6108 | |||
| 6109 | |||
| 6110 | |||
| 6111 | enterRule(); | ||
| 6112 | |||
| 6113 | try { | ||
| 6114 | // InternalSolverLanguageParser.g:2375:2: ( ( (lv_value_0_0= ruleReal ) ) ) | ||
| 6115 | // InternalSolverLanguageParser.g:2376:2: ( (lv_value_0_0= ruleReal ) ) | ||
| 6116 | { | ||
| 6117 | // InternalSolverLanguageParser.g:2376:2: ( (lv_value_0_0= ruleReal ) ) | ||
| 6118 | // InternalSolverLanguageParser.g:2377:3: (lv_value_0_0= ruleReal ) | ||
| 6119 | { | ||
| 6120 | // InternalSolverLanguageParser.g:2377:3: (lv_value_0_0= ruleReal ) | ||
| 6121 | // InternalSolverLanguageParser.g:2378:4: lv_value_0_0= ruleReal | ||
| 6122 | { | ||
| 6123 | |||
| 6124 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | ||
| 6125 | |||
| 6126 | pushFollow(FOLLOW_2); | ||
| 6127 | lv_value_0_0=ruleReal(); | ||
| 6128 | |||
| 6129 | state._fsp--; | ||
| 6130 | |||
| 6131 | |||
| 6132 | if (current==null) { | ||
| 6133 | current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); | ||
| 6134 | } | ||
| 6135 | set( | ||
| 6136 | current, | ||
| 6137 | "value", | ||
| 6138 | lv_value_0_0, | ||
| 6139 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
| 6140 | afterParserOrEnumRuleCall(); | ||
| 6141 | |||
| 6142 | |||
| 6143 | } | ||
| 4506 | 6144 | ||
| 4507 | } | ||
| 4508 | break; | ||
| 4509 | 6145 | ||
| 4510 | } | 6146 | } |
| 4511 | 6147 | ||
| @@ -4525,28 +6161,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4525 | } | 6161 | } |
| 4526 | return current; | 6162 | return current; |
| 4527 | } | 6163 | } |
| 4528 | // $ANTLR end "rulePolarity" | 6164 | // $ANTLR end "ruleNumericLiteral" |
| 4529 | 6165 | ||
| 4530 | 6166 | ||
| 4531 | // $ANTLR start "entryRuleConstraint" | 6167 | // $ANTLR start "entryRuleInfinityLiteral" |
| 4532 | // InternalSolverLanguage.g:1543:1: entryRuleConstraint returns [EObject current=null] : iv_ruleConstraint= ruleConstraint EOF ; | 6168 | // InternalSolverLanguageParser.g:2398:1: entryRuleInfinityLiteral returns [EObject current=null] : iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ; |
| 4533 | public final EObject entryRuleConstraint() throws RecognitionException { | 6169 | public final EObject entryRuleInfinityLiteral() throws RecognitionException { |
| 4534 | EObject current = null; | 6170 | EObject current = null; |
| 4535 | 6171 | ||
| 4536 | EObject iv_ruleConstraint = null; | 6172 | EObject iv_ruleInfinityLiteral = null; |
| 4537 | 6173 | ||
| 4538 | 6174 | ||
| 4539 | try { | 6175 | try { |
| 4540 | // InternalSolverLanguage.g:1543:51: (iv_ruleConstraint= ruleConstraint EOF ) | 6176 | // InternalSolverLanguageParser.g:2398:56: (iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ) |
| 4541 | // InternalSolverLanguage.g:1544:2: iv_ruleConstraint= ruleConstraint EOF | 6177 | // InternalSolverLanguageParser.g:2399:2: iv_ruleInfinityLiteral= ruleInfinityLiteral EOF |
| 4542 | { | 6178 | { |
| 4543 | newCompositeNode(grammarAccess.getConstraintRule()); | 6179 | newCompositeNode(grammarAccess.getInfinityLiteralRule()); |
| 4544 | pushFollow(FOLLOW_1); | 6180 | pushFollow(FOLLOW_1); |
| 4545 | iv_ruleConstraint=ruleConstraint(); | 6181 | iv_ruleInfinityLiteral=ruleInfinityLiteral(); |
| 4546 | 6182 | ||
| 4547 | state._fsp--; | 6183 | state._fsp--; |
| 4548 | 6184 | ||
| 4549 | current =iv_ruleConstraint; | 6185 | current =iv_ruleInfinityLiteral; |
| 4550 | match(input,EOF,FOLLOW_2); | 6186 | match(input,EOF,FOLLOW_2); |
| 4551 | 6187 | ||
| 4552 | } | 6188 | } |
| @@ -4561,418 +6197,454 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4561 | } | 6197 | } |
| 4562 | return current; | 6198 | return current; |
| 4563 | } | 6199 | } |
| 4564 | // $ANTLR end "entryRuleConstraint" | 6200 | // $ANTLR end "entryRuleInfinityLiteral" |
| 4565 | 6201 | ||
| 4566 | 6202 | ||
| 4567 | // $ANTLR start "ruleConstraint" | 6203 | // $ANTLR start "ruleInfinityLiteral" |
| 4568 | // InternalSolverLanguage.g:1550:1: ruleConstraint returns [EObject current=null] : ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) ; | 6204 | // InternalSolverLanguageParser.g:2405:1: ruleInfinityLiteral returns [EObject current=null] : ( () otherlv_1= Inf ) ; |
| 4569 | public final EObject ruleConstraint() throws RecognitionException { | 6205 | public final EObject ruleInfinityLiteral() throws RecognitionException { |
| 4570 | EObject current = null; | 6206 | EObject current = null; |
| 4571 | 6207 | ||
| 4572 | Token otherlv_2=null; | 6208 | Token otherlv_1=null; |
| 4573 | Token otherlv_4=null; | 6209 | |
| 4574 | Token otherlv_6=null; | 6210 | |
| 4575 | Token otherlv_8=null; | 6211 | enterRule(); |
| 4576 | Token otherlv_10=null; | 6212 | |
| 4577 | Token otherlv_12=null; | 6213 | try { |
| 4578 | EObject lv_polarity_0_0 = null; | 6214 | // InternalSolverLanguageParser.g:2411:2: ( ( () otherlv_1= Inf ) ) |
| 6215 | // InternalSolverLanguageParser.g:2412:2: ( () otherlv_1= Inf ) | ||
| 6216 | { | ||
| 6217 | // InternalSolverLanguageParser.g:2412:2: ( () otherlv_1= Inf ) | ||
| 6218 | // InternalSolverLanguageParser.g:2413:3: () otherlv_1= Inf | ||
| 6219 | { | ||
| 6220 | // InternalSolverLanguageParser.g:2413:3: () | ||
| 6221 | // InternalSolverLanguageParser.g:2414:4: | ||
| 6222 | { | ||
| 4579 | 6223 | ||
| 4580 | EObject lv_symbol_1_0 = null; | 6224 | current = forceCreateModelElement( |
| 6225 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
| 6226 | current); | ||
| 6227 | |||
| 4581 | 6228 | ||
| 4582 | EObject lv_params_3_0 = null; | 6229 | } |
| 4583 | 6230 | ||
| 4584 | EObject lv_params_5_0 = null; | 6231 | otherlv_1=(Token)match(input,Inf,FOLLOW_2); |
| 4585 | 6232 | ||
| 4586 | EObject lv_closureType_7_0 = null; | 6233 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
| 6234 | |||
| 4587 | 6235 | ||
| 4588 | EObject lv_params_9_0 = null; | 6236 | } |
| 4589 | 6237 | ||
| 4590 | EObject lv_params_11_0 = null; | ||
| 4591 | 6238 | ||
| 6239 | } | ||
| 6240 | |||
| 6241 | |||
| 6242 | leaveRule(); | ||
| 6243 | |||
| 6244 | } | ||
| 6245 | |||
| 6246 | catch (RecognitionException re) { | ||
| 6247 | recover(input,re); | ||
| 6248 | appendSkippedTokens(); | ||
| 6249 | } | ||
| 6250 | finally { | ||
| 6251 | } | ||
| 6252 | return current; | ||
| 6253 | } | ||
| 6254 | // $ANTLR end "ruleInfinityLiteral" | ||
| 6255 | |||
| 6256 | |||
| 6257 | // $ANTLR start "entryRuleEmptyIntervalLiteral" | ||
| 6258 | // InternalSolverLanguageParser.g:2428:1: entryRuleEmptyIntervalLiteral returns [EObject current=null] : iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ; | ||
| 6259 | public final EObject entryRuleEmptyIntervalLiteral() throws RecognitionException { | ||
| 6260 | EObject current = null; | ||
| 6261 | |||
| 6262 | EObject iv_ruleEmptyIntervalLiteral = null; | ||
| 6263 | |||
| 6264 | |||
| 6265 | try { | ||
| 6266 | // InternalSolverLanguageParser.g:2428:61: (iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ) | ||
| 6267 | // InternalSolverLanguageParser.g:2429:2: iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF | ||
| 6268 | { | ||
| 6269 | newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); | ||
| 6270 | pushFollow(FOLLOW_1); | ||
| 6271 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral(); | ||
| 6272 | |||
| 6273 | state._fsp--; | ||
| 6274 | |||
| 6275 | current =iv_ruleEmptyIntervalLiteral; | ||
| 6276 | match(input,EOF,FOLLOW_2); | ||
| 6277 | |||
| 6278 | } | ||
| 6279 | |||
| 6280 | } | ||
| 6281 | |||
| 6282 | catch (RecognitionException re) { | ||
| 6283 | recover(input,re); | ||
| 6284 | appendSkippedTokens(); | ||
| 6285 | } | ||
| 6286 | finally { | ||
| 6287 | } | ||
| 6288 | return current; | ||
| 6289 | } | ||
| 6290 | // $ANTLR end "entryRuleEmptyIntervalLiteral" | ||
| 6291 | |||
| 6292 | |||
| 6293 | // $ANTLR start "ruleEmptyIntervalLiteral" | ||
| 6294 | // InternalSolverLanguageParser.g:2435:1: ruleEmptyIntervalLiteral returns [EObject current=null] : ( () otherlv_1= Empty ) ; | ||
| 6295 | public final EObject ruleEmptyIntervalLiteral() throws RecognitionException { | ||
| 6296 | EObject current = null; | ||
| 6297 | |||
| 6298 | Token otherlv_1=null; | ||
| 4592 | 6299 | ||
| 4593 | 6300 | ||
| 4594 | enterRule(); | 6301 | enterRule(); |
| 4595 | 6302 | ||
| 4596 | try { | 6303 | try { |
| 4597 | // InternalSolverLanguage.g:1556:2: ( ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) ) | 6304 | // InternalSolverLanguageParser.g:2441:2: ( ( () otherlv_1= Empty ) ) |
| 4598 | // InternalSolverLanguage.g:1557:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) | 6305 | // InternalSolverLanguageParser.g:2442:2: ( () otherlv_1= Empty ) |
| 6306 | { | ||
| 6307 | // InternalSolverLanguageParser.g:2442:2: ( () otherlv_1= Empty ) | ||
| 6308 | // InternalSolverLanguageParser.g:2443:3: () otherlv_1= Empty | ||
| 6309 | { | ||
| 6310 | // InternalSolverLanguageParser.g:2443:3: () | ||
| 6311 | // InternalSolverLanguageParser.g:2444:4: | ||
| 4599 | { | 6312 | { |
| 4600 | // InternalSolverLanguage.g:1557:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) ) | ||
| 4601 | int alt33=2; | ||
| 4602 | switch ( input.LA(1) ) { | ||
| 4603 | case 30: | ||
| 4604 | { | ||
| 4605 | int LA33_1 = input.LA(2); | ||
| 4606 | 6313 | ||
| 4607 | if ( (LA33_1==17) ) { | 6314 | current = forceCreateModelElement( |
| 4608 | alt33=2; | 6315 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), |
| 4609 | } | 6316 | current); |
| 4610 | else if ( (LA33_1==RULE_ID) ) { | 6317 | |
| 4611 | alt33=1; | ||
| 4612 | } | ||
| 4613 | else { | ||
| 4614 | NoViableAltException nvae = | ||
| 4615 | new NoViableAltException("", 33, 1, input); | ||
| 4616 | 6318 | ||
| 4617 | throw nvae; | 6319 | } |
| 4618 | } | 6320 | |
| 4619 | } | 6321 | otherlv_1=(Token)match(input,Empty,FOLLOW_2); |
| 4620 | break; | 6322 | |
| 4621 | case RULE_ID: | 6323 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); |
| 4622 | case 11: | 6324 | |
| 4623 | { | ||
| 4624 | alt33=1; | ||
| 4625 | } | ||
| 4626 | break; | ||
| 4627 | case 31: | ||
| 4628 | { | ||
| 4629 | alt33=2; | ||
| 4630 | } | ||
| 4631 | break; | ||
| 4632 | default: | ||
| 4633 | NoViableAltException nvae = | ||
| 4634 | new NoViableAltException("", 33, 0, input); | ||
| 4635 | 6325 | ||
| 4636 | throw nvae; | ||
| 4637 | } | 6326 | } |
| 4638 | 6327 | ||
| 4639 | switch (alt33) { | ||
| 4640 | case 1 : | ||
| 4641 | // InternalSolverLanguage.g:1558:3: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ||
| 4642 | { | ||
| 4643 | // InternalSolverLanguage.g:1558:3: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? ) | ||
| 4644 | // InternalSolverLanguage.g:1559:4: ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? | ||
| 4645 | { | ||
| 4646 | // InternalSolverLanguage.g:1559:4: ( (lv_polarity_0_0= rulePolarity ) )? | ||
| 4647 | int alt27=2; | ||
| 4648 | int LA27_0 = input.LA(1); | ||
| 4649 | 6328 | ||
| 4650 | if ( (LA27_0==11||LA27_0==30) ) { | 6329 | } |
| 4651 | alt27=1; | ||
| 4652 | } | ||
| 4653 | switch (alt27) { | ||
| 4654 | case 1 : | ||
| 4655 | // InternalSolverLanguage.g:1560:5: (lv_polarity_0_0= rulePolarity ) | ||
| 4656 | { | ||
| 4657 | // InternalSolverLanguage.g:1560:5: (lv_polarity_0_0= rulePolarity ) | ||
| 4658 | // InternalSolverLanguage.g:1561:6: lv_polarity_0_0= rulePolarity | ||
| 4659 | { | ||
| 4660 | 6330 | ||
| 4661 | newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); | ||
| 4662 | |||
| 4663 | pushFollow(FOLLOW_12); | ||
| 4664 | lv_polarity_0_0=rulePolarity(); | ||
| 4665 | 6331 | ||
| 4666 | state._fsp--; | 6332 | leaveRule(); |
| 4667 | 6333 | ||
| 6334 | } | ||
| 4668 | 6335 | ||
| 4669 | if (current==null) { | 6336 | catch (RecognitionException re) { |
| 4670 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 6337 | recover(input,re); |
| 4671 | } | 6338 | appendSkippedTokens(); |
| 4672 | set( | 6339 | } |
| 4673 | current, | 6340 | finally { |
| 4674 | "polarity", | 6341 | } |
| 4675 | lv_polarity_0_0, | 6342 | return current; |
| 4676 | "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | 6343 | } |
| 4677 | afterParserOrEnumRuleCall(); | 6344 | // $ANTLR end "ruleEmptyIntervalLiteral" |
| 4678 | |||
| 4679 | 6345 | ||
| 4680 | } | ||
| 4681 | 6346 | ||
| 6347 | // $ANTLR start "entryRuleStringLiteral" | ||
| 6348 | // InternalSolverLanguageParser.g:2458:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ; | ||
| 6349 | public final EObject entryRuleStringLiteral() throws RecognitionException { | ||
| 6350 | EObject current = null; | ||
| 4682 | 6351 | ||
| 4683 | } | 6352 | EObject iv_ruleStringLiteral = null; |
| 4684 | break; | ||
| 4685 | 6353 | ||
| 4686 | } | ||
| 4687 | 6354 | ||
| 4688 | // InternalSolverLanguage.g:1578:4: ( (lv_symbol_1_0= ruleModelSymbol ) ) | 6355 | try { |
| 4689 | // InternalSolverLanguage.g:1579:5: (lv_symbol_1_0= ruleModelSymbol ) | 6356 | // InternalSolverLanguageParser.g:2458:54: (iv_ruleStringLiteral= ruleStringLiteral EOF ) |
| 4690 | { | 6357 | // InternalSolverLanguageParser.g:2459:2: iv_ruleStringLiteral= ruleStringLiteral EOF |
| 4691 | // InternalSolverLanguage.g:1579:5: (lv_symbol_1_0= ruleModelSymbol ) | 6358 | { |
| 4692 | // InternalSolverLanguage.g:1580:6: lv_symbol_1_0= ruleModelSymbol | 6359 | newCompositeNode(grammarAccess.getStringLiteralRule()); |
| 4693 | { | 6360 | pushFollow(FOLLOW_1); |
| 6361 | iv_ruleStringLiteral=ruleStringLiteral(); | ||
| 4694 | 6362 | ||
| 4695 | newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); | 6363 | state._fsp--; |
| 4696 | |||
| 4697 | pushFollow(FOLLOW_23); | ||
| 4698 | lv_symbol_1_0=ruleModelSymbol(); | ||
| 4699 | 6364 | ||
| 4700 | state._fsp--; | 6365 | current =iv_ruleStringLiteral; |
| 6366 | match(input,EOF,FOLLOW_2); | ||
| 4701 | 6367 | ||
| 6368 | } | ||
| 4702 | 6369 | ||
| 4703 | if (current==null) { | 6370 | } |
| 4704 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4705 | } | ||
| 4706 | set( | ||
| 4707 | current, | ||
| 4708 | "symbol", | ||
| 4709 | lv_symbol_1_0, | ||
| 4710 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 4711 | afterParserOrEnumRuleCall(); | ||
| 4712 | |||
| 4713 | 6371 | ||
| 4714 | } | 6372 | catch (RecognitionException re) { |
| 6373 | recover(input,re); | ||
| 6374 | appendSkippedTokens(); | ||
| 6375 | } | ||
| 6376 | finally { | ||
| 6377 | } | ||
| 6378 | return current; | ||
| 6379 | } | ||
| 6380 | // $ANTLR end "entryRuleStringLiteral" | ||
| 4715 | 6381 | ||
| 4716 | 6382 | ||
| 4717 | } | 6383 | // $ANTLR start "ruleStringLiteral" |
| 6384 | // InternalSolverLanguageParser.g:2465:1: ruleStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | ||
| 6385 | public final EObject ruleStringLiteral() throws RecognitionException { | ||
| 6386 | EObject current = null; | ||
| 4718 | 6387 | ||
| 4719 | // InternalSolverLanguage.g:1597:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' )? | 6388 | Token lv_value_0_0=null; |
| 4720 | int alt30=2; | ||
| 4721 | int LA30_0 = input.LA(1); | ||
| 4722 | 6389 | ||
| 4723 | if ( (LA30_0==17) ) { | ||
| 4724 | alt30=1; | ||
| 4725 | } | ||
| 4726 | switch (alt30) { | ||
| 4727 | case 1 : | ||
| 4728 | // InternalSolverLanguage.g:1598:5: otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )? (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* otherlv_6= ')' | ||
| 4729 | { | ||
| 4730 | otherlv_2=(Token)match(input,17,FOLLOW_24); | ||
| 4731 | 6390 | ||
| 4732 | newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); | 6391 | enterRule(); |
| 4733 | |||
| 4734 | // InternalSolverLanguage.g:1602:5: ( (lv_params_3_0= ruleLiteral ) )? | ||
| 4735 | int alt28=2; | ||
| 4736 | int LA28_0 = input.LA(1); | ||
| 4737 | 6392 | ||
| 4738 | if ( ((LA28_0>=RULE_INT && LA28_0<=RULE_STRING)||LA28_0==11||(LA28_0>=13 && LA28_0<=14)||LA28_0==27) ) { | 6393 | try { |
| 4739 | alt28=1; | 6394 | // InternalSolverLanguageParser.g:2471:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) |
| 4740 | } | 6395 | // InternalSolverLanguageParser.g:2472:2: ( (lv_value_0_0= RULE_STRING ) ) |
| 4741 | switch (alt28) { | 6396 | { |
| 4742 | case 1 : | 6397 | // InternalSolverLanguageParser.g:2472:2: ( (lv_value_0_0= RULE_STRING ) ) |
| 4743 | // InternalSolverLanguage.g:1603:6: (lv_params_3_0= ruleLiteral ) | 6398 | // InternalSolverLanguageParser.g:2473:3: (lv_value_0_0= RULE_STRING ) |
| 4744 | { | 6399 | { |
| 4745 | // InternalSolverLanguage.g:1603:6: (lv_params_3_0= ruleLiteral ) | 6400 | // InternalSolverLanguageParser.g:2473:3: (lv_value_0_0= RULE_STRING ) |
| 4746 | // InternalSolverLanguage.g:1604:7: lv_params_3_0= ruleLiteral | 6401 | // InternalSolverLanguageParser.g:2474:4: lv_value_0_0= RULE_STRING |
| 4747 | { | 6402 | { |
| 6403 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); | ||
| 6404 | |||
| 6405 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | ||
| 6406 | |||
| 4748 | 6407 | ||
| 4749 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); | 6408 | if (current==null) { |
| 4750 | 6409 | current = createModelElement(grammarAccess.getStringLiteralRule()); | |
| 4751 | pushFollow(FOLLOW_8); | 6410 | } |
| 4752 | lv_params_3_0=ruleLiteral(); | 6411 | setWithLastConsumed( |
| 6412 | current, | ||
| 6413 | "value", | ||
| 6414 | lv_value_0_0, | ||
| 6415 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 6416 | |||
| 4753 | 6417 | ||
| 4754 | state._fsp--; | 6418 | } |
| 4755 | 6419 | ||
| 4756 | 6420 | ||
| 4757 | if (current==null) { | 6421 | } |
| 4758 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4759 | } | ||
| 4760 | add( | ||
| 4761 | current, | ||
| 4762 | "params", | ||
| 4763 | lv_params_3_0, | ||
| 4764 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4765 | afterParserOrEnumRuleCall(); | ||
| 4766 | |||
| 4767 | 6422 | ||
| 4768 | } | ||
| 4769 | 6423 | ||
| 6424 | } | ||
| 4770 | 6425 | ||
| 4771 | } | ||
| 4772 | break; | ||
| 4773 | 6426 | ||
| 4774 | } | 6427 | leaveRule(); |
| 4775 | 6428 | ||
| 4776 | // InternalSolverLanguage.g:1621:5: (otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) )* | 6429 | } |
| 4777 | loop29: | ||
| 4778 | do { | ||
| 4779 | int alt29=2; | ||
| 4780 | int LA29_0 = input.LA(1); | ||
| 4781 | 6430 | ||
| 4782 | if ( (LA29_0==18) ) { | 6431 | catch (RecognitionException re) { |
| 4783 | alt29=1; | 6432 | recover(input,re); |
| 4784 | } | 6433 | appendSkippedTokens(); |
| 6434 | } | ||
| 6435 | finally { | ||
| 6436 | } | ||
| 6437 | return current; | ||
| 6438 | } | ||
| 6439 | // $ANTLR end "ruleStringLiteral" | ||
| 4785 | 6440 | ||
| 4786 | 6441 | ||
| 4787 | switch (alt29) { | 6442 | // $ANTLR start "entryRuleClassDefinition" |
| 4788 | case 1 : | 6443 | // InternalSolverLanguageParser.g:2493:1: entryRuleClassDefinition returns [EObject current=null] : iv_ruleClassDefinition= ruleClassDefinition EOF ; |
| 4789 | // InternalSolverLanguage.g:1622:6: otherlv_4= ',' ( (lv_params_5_0= ruleLiteral ) ) | 6444 | public final EObject entryRuleClassDefinition() throws RecognitionException { |
| 4790 | { | 6445 | EObject current = null; |
| 4791 | otherlv_4=(Token)match(input,18,FOLLOW_25); | ||
| 4792 | 6446 | ||
| 4793 | newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); | 6447 | EObject iv_ruleClassDefinition = null; |
| 4794 | |||
| 4795 | // InternalSolverLanguage.g:1626:6: ( (lv_params_5_0= ruleLiteral ) ) | ||
| 4796 | // InternalSolverLanguage.g:1627:7: (lv_params_5_0= ruleLiteral ) | ||
| 4797 | { | ||
| 4798 | // InternalSolverLanguage.g:1627:7: (lv_params_5_0= ruleLiteral ) | ||
| 4799 | // InternalSolverLanguage.g:1628:8: lv_params_5_0= ruleLiteral | ||
| 4800 | { | ||
| 4801 | 6448 | ||
| 4802 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); | ||
| 4803 | |||
| 4804 | pushFollow(FOLLOW_8); | ||
| 4805 | lv_params_5_0=ruleLiteral(); | ||
| 4806 | 6449 | ||
| 4807 | state._fsp--; | 6450 | try { |
| 6451 | // InternalSolverLanguageParser.g:2493:56: (iv_ruleClassDefinition= ruleClassDefinition EOF ) | ||
| 6452 | // InternalSolverLanguageParser.g:2494:2: iv_ruleClassDefinition= ruleClassDefinition EOF | ||
| 6453 | { | ||
| 6454 | newCompositeNode(grammarAccess.getClassDefinitionRule()); | ||
| 6455 | pushFollow(FOLLOW_1); | ||
| 6456 | iv_ruleClassDefinition=ruleClassDefinition(); | ||
| 4808 | 6457 | ||
| 6458 | state._fsp--; | ||
| 4809 | 6459 | ||
| 4810 | if (current==null) { | 6460 | current =iv_ruleClassDefinition; |
| 4811 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 6461 | match(input,EOF,FOLLOW_2); |
| 4812 | } | ||
| 4813 | add( | ||
| 4814 | current, | ||
| 4815 | "params", | ||
| 4816 | lv_params_5_0, | ||
| 4817 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4818 | afterParserOrEnumRuleCall(); | ||
| 4819 | |||
| 4820 | 6462 | ||
| 4821 | } | 6463 | } |
| 4822 | 6464 | ||
| 6465 | } | ||
| 4823 | 6466 | ||
| 4824 | } | 6467 | catch (RecognitionException re) { |
| 6468 | recover(input,re); | ||
| 6469 | appendSkippedTokens(); | ||
| 6470 | } | ||
| 6471 | finally { | ||
| 6472 | } | ||
| 6473 | return current; | ||
| 6474 | } | ||
| 6475 | // $ANTLR end "entryRuleClassDefinition" | ||
| 4825 | 6476 | ||
| 4826 | 6477 | ||
| 4827 | } | 6478 | // $ANTLR start "ruleClassDefinition" |
| 4828 | break; | 6479 | // InternalSolverLanguageParser.g:2500:1: ruleClassDefinition returns [EObject current=null] : ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) ; |
| 6480 | public final EObject ruleClassDefinition() throws RecognitionException { | ||
| 6481 | EObject current = null; | ||
| 4829 | 6482 | ||
| 4830 | default : | 6483 | Token lv_abstract_0_0=null; |
| 4831 | break loop29; | 6484 | Token otherlv_1=null; |
| 4832 | } | 6485 | Token lv_name_2_0=null; |
| 4833 | } while (true); | 6486 | Token otherlv_3=null; |
| 6487 | Token otherlv_5=null; | ||
| 6488 | Token otherlv_7=null; | ||
| 6489 | Token otherlv_9=null; | ||
| 6490 | EObject lv_members_8_0 = null; | ||
| 4834 | 6491 | ||
| 4835 | otherlv_6=(Token)match(input,19,FOLLOW_2); | ||
| 4836 | 6492 | ||
| 4837 | newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); | ||
| 4838 | |||
| 4839 | 6493 | ||
| 4840 | } | 6494 | enterRule(); |
| 4841 | break; | ||
| 4842 | 6495 | ||
| 4843 | } | 6496 | try { |
| 6497 | // InternalSolverLanguageParser.g:2506:2: ( ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) ) | ||
| 6498 | // InternalSolverLanguageParser.g:2507:2: ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) | ||
| 6499 | { | ||
| 6500 | // InternalSolverLanguageParser.g:2507:2: ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) | ||
| 6501 | // InternalSolverLanguageParser.g:2508:3: ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket | ||
| 6502 | { | ||
| 6503 | // InternalSolverLanguageParser.g:2508:3: ( (lv_abstract_0_0= Abstract ) )? | ||
| 6504 | int alt26=2; | ||
| 6505 | int LA26_0 = input.LA(1); | ||
| 4844 | 6506 | ||
| 6507 | if ( (LA26_0==Abstract) ) { | ||
| 6508 | alt26=1; | ||
| 6509 | } | ||
| 6510 | switch (alt26) { | ||
| 6511 | case 1 : | ||
| 6512 | // InternalSolverLanguageParser.g:2509:4: (lv_abstract_0_0= Abstract ) | ||
| 6513 | { | ||
| 6514 | // InternalSolverLanguageParser.g:2509:4: (lv_abstract_0_0= Abstract ) | ||
| 6515 | // InternalSolverLanguageParser.g:2510:5: lv_abstract_0_0= Abstract | ||
| 6516 | { | ||
| 6517 | lv_abstract_0_0=(Token)match(input,Abstract,FOLLOW_37); | ||
| 6518 | |||
| 6519 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | ||
| 6520 | |||
| 6521 | |||
| 6522 | if (current==null) { | ||
| 6523 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 6524 | } | ||
| 6525 | setWithLastConsumed(current, "abstract", true, "abstract"); | ||
| 6526 | |||
| 4845 | 6527 | ||
| 4846 | } | 6528 | } |
| 4847 | 6529 | ||
| 4848 | 6530 | ||
| 4849 | } | 6531 | } |
| 4850 | break; | 6532 | break; |
| 4851 | case 2 : | ||
| 4852 | // InternalSolverLanguage.g:1653:3: ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) | ||
| 4853 | { | ||
| 4854 | // InternalSolverLanguage.g:1653:3: ( ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' ) | ||
| 4855 | // InternalSolverLanguage.g:1654:4: ( (lv_closureType_7_0= ruleClosureType ) ) otherlv_8= '(' ( (lv_params_9_0= ruleLiteral ) )? (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* otherlv_12= ')' | ||
| 4856 | { | ||
| 4857 | // InternalSolverLanguage.g:1654:4: ( (lv_closureType_7_0= ruleClosureType ) ) | ||
| 4858 | // InternalSolverLanguage.g:1655:5: (lv_closureType_7_0= ruleClosureType ) | ||
| 4859 | { | ||
| 4860 | // InternalSolverLanguage.g:1655:5: (lv_closureType_7_0= ruleClosureType ) | ||
| 4861 | // InternalSolverLanguage.g:1656:6: lv_closureType_7_0= ruleClosureType | ||
| 4862 | { | ||
| 4863 | 6533 | ||
| 4864 | newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); | 6534 | } |
| 4865 | |||
| 4866 | pushFollow(FOLLOW_26); | ||
| 4867 | lv_closureType_7_0=ruleClosureType(); | ||
| 4868 | 6535 | ||
| 4869 | state._fsp--; | 6536 | otherlv_1=(Token)match(input,Class,FOLLOW_38); |
| 4870 | 6537 | ||
| 6538 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | ||
| 6539 | |||
| 6540 | // InternalSolverLanguageParser.g:2526:3: ( (lv_name_2_0= RULE_ID ) ) | ||
| 6541 | // InternalSolverLanguageParser.g:2527:4: (lv_name_2_0= RULE_ID ) | ||
| 6542 | { | ||
| 6543 | // InternalSolverLanguageParser.g:2527:4: (lv_name_2_0= RULE_ID ) | ||
| 6544 | // InternalSolverLanguageParser.g:2528:5: lv_name_2_0= RULE_ID | ||
| 6545 | { | ||
| 6546 | lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_39); | ||
| 4871 | 6547 | ||
| 4872 | if (current==null) { | 6548 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
| 4873 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | 6549 | |
| 4874 | } | ||
| 4875 | set( | ||
| 4876 | current, | ||
| 4877 | "closureType", | ||
| 4878 | lv_closureType_7_0, | ||
| 4879 | "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | ||
| 4880 | afterParserOrEnumRuleCall(); | ||
| 4881 | |||
| 4882 | 6550 | ||
| 4883 | } | 6551 | if (current==null) { |
| 6552 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 6553 | } | ||
| 6554 | setWithLastConsumed( | ||
| 6555 | current, | ||
| 6556 | "name", | ||
| 6557 | lv_name_2_0, | ||
| 6558 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 6559 | |||
| 4884 | 6560 | ||
| 6561 | } | ||
| 4885 | 6562 | ||
| 4886 | } | ||
| 4887 | 6563 | ||
| 4888 | otherlv_8=(Token)match(input,17,FOLLOW_24); | 6564 | } |
| 4889 | 6565 | ||
| 4890 | newLeafNode(otherlv_8, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); | 6566 | // InternalSolverLanguageParser.g:2544:3: (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? |
| 4891 | 6567 | int alt28=2; | |
| 4892 | // InternalSolverLanguage.g:1677:4: ( (lv_params_9_0= ruleLiteral ) )? | 6568 | int LA28_0 = input.LA(1); |
| 4893 | int alt31=2; | ||
| 4894 | int LA31_0 = input.LA(1); | ||
| 4895 | 6569 | ||
| 4896 | if ( ((LA31_0>=RULE_INT && LA31_0<=RULE_STRING)||LA31_0==11||(LA31_0>=13 && LA31_0<=14)||LA31_0==27) ) { | 6570 | if ( (LA28_0==Extends) ) { |
| 4897 | alt31=1; | 6571 | alt28=1; |
| 4898 | } | 6572 | } |
| 4899 | switch (alt31) { | 6573 | switch (alt28) { |
| 4900 | case 1 : | 6574 | case 1 : |
| 4901 | // InternalSolverLanguage.g:1678:5: (lv_params_9_0= ruleLiteral ) | 6575 | // InternalSolverLanguageParser.g:2545:4: otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* |
| 4902 | { | 6576 | { |
| 4903 | // InternalSolverLanguage.g:1678:5: (lv_params_9_0= ruleLiteral ) | 6577 | otherlv_3=(Token)match(input,Extends,FOLLOW_8); |
| 4904 | // InternalSolverLanguage.g:1679:6: lv_params_9_0= ruleLiteral | ||
| 4905 | { | ||
| 4906 | 6578 | ||
| 4907 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); | 6579 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
| 4908 | 6580 | ||
| 4909 | pushFollow(FOLLOW_8); | 6581 | // InternalSolverLanguageParser.g:2549:4: ( ( ruleQualifiedName ) ) |
| 4910 | lv_params_9_0=ruleLiteral(); | 6582 | // InternalSolverLanguageParser.g:2550:5: ( ruleQualifiedName ) |
| 6583 | { | ||
| 6584 | // InternalSolverLanguageParser.g:2550:5: ( ruleQualifiedName ) | ||
| 6585 | // InternalSolverLanguageParser.g:2551:6: ruleQualifiedName | ||
| 6586 | { | ||
| 4911 | 6587 | ||
| 4912 | state._fsp--; | 6588 | if (current==null) { |
| 6589 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 6590 | } | ||
| 6591 | |||
| 4913 | 6592 | ||
| 6593 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | ||
| 6594 | |||
| 6595 | pushFollow(FOLLOW_40); | ||
| 6596 | ruleQualifiedName(); | ||
| 4914 | 6597 | ||
| 4915 | if (current==null) { | 6598 | state._fsp--; |
| 4916 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4917 | } | ||
| 4918 | add( | ||
| 4919 | current, | ||
| 4920 | "params", | ||
| 4921 | lv_params_9_0, | ||
| 4922 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4923 | afterParserOrEnumRuleCall(); | ||
| 4924 | |||
| 4925 | 6599 | ||
| 4926 | } | ||
| 4927 | 6600 | ||
| 6601 | afterParserOrEnumRuleCall(); | ||
| 6602 | |||
| 6603 | |||
| 6604 | } | ||
| 4928 | 6605 | ||
| 4929 | } | ||
| 4930 | break; | ||
| 4931 | 6606 | ||
| 4932 | } | 6607 | } |
| 4933 | 6608 | ||
| 4934 | // InternalSolverLanguage.g:1696:4: (otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) )* | 6609 | // InternalSolverLanguageParser.g:2565:4: (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* |
| 4935 | loop32: | 6610 | loop27: |
| 4936 | do { | 6611 | do { |
| 4937 | int alt32=2; | 6612 | int alt27=2; |
| 4938 | int LA32_0 = input.LA(1); | 6613 | int LA27_0 = input.LA(1); |
| 4939 | 6614 | ||
| 4940 | if ( (LA32_0==18) ) { | 6615 | if ( (LA27_0==Comma) ) { |
| 4941 | alt32=1; | 6616 | alt27=1; |
| 4942 | } | 6617 | } |
| 4943 | 6618 | ||
| 4944 | 6619 | ||
| 4945 | switch (alt32) { | 6620 | switch (alt27) { |
| 4946 | case 1 : | 6621 | case 1 : |
| 4947 | // InternalSolverLanguage.g:1697:5: otherlv_10= ',' ( (lv_params_11_0= ruleLiteral ) ) | 6622 | // InternalSolverLanguageParser.g:2566:5: otherlv_5= Comma ( ( ruleQualifiedName ) ) |
| 4948 | { | 6623 | { |
| 4949 | otherlv_10=(Token)match(input,18,FOLLOW_25); | 6624 | otherlv_5=(Token)match(input,Comma,FOLLOW_8); |
| 4950 | 6625 | ||
| 4951 | newLeafNode(otherlv_10, grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); | 6626 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
| 4952 | 6627 | ||
| 4953 | // InternalSolverLanguage.g:1701:5: ( (lv_params_11_0= ruleLiteral ) ) | 6628 | // InternalSolverLanguageParser.g:2570:5: ( ( ruleQualifiedName ) ) |
| 4954 | // InternalSolverLanguage.g:1702:6: (lv_params_11_0= ruleLiteral ) | 6629 | // InternalSolverLanguageParser.g:2571:6: ( ruleQualifiedName ) |
| 4955 | { | 6630 | { |
| 4956 | // InternalSolverLanguage.g:1702:6: (lv_params_11_0= ruleLiteral ) | 6631 | // InternalSolverLanguageParser.g:2571:6: ( ruleQualifiedName ) |
| 4957 | // InternalSolverLanguage.g:1703:7: lv_params_11_0= ruleLiteral | 6632 | // InternalSolverLanguageParser.g:2572:7: ruleQualifiedName |
| 4958 | { | 6633 | { |
| 4959 | 6634 | ||
| 4960 | newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); | 6635 | if (current==null) { |
| 6636 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | ||
| 6637 | } | ||
| 6638 | |||
| 6639 | |||
| 6640 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | ||
| 4961 | 6641 | ||
| 4962 | pushFollow(FOLLOW_8); | 6642 | pushFollow(FOLLOW_40); |
| 4963 | lv_params_11_0=ruleLiteral(); | 6643 | ruleQualifiedName(); |
| 4964 | 6644 | ||
| 4965 | state._fsp--; | 6645 | state._fsp--; |
| 4966 | 6646 | ||
| 4967 | 6647 | ||
| 4968 | if (current==null) { | ||
| 4969 | current = createModelElementForParent(grammarAccess.getConstraintRule()); | ||
| 4970 | } | ||
| 4971 | add( | ||
| 4972 | current, | ||
| 4973 | "params", | ||
| 4974 | lv_params_11_0, | ||
| 4975 | "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 4976 | afterParserOrEnumRuleCall(); | 6648 | afterParserOrEnumRuleCall(); |
| 4977 | 6649 | ||
| 4978 | 6650 | ||
| @@ -4986,20 +6658,73 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 4986 | break; | 6658 | break; |
| 4987 | 6659 | ||
| 4988 | default : | 6660 | default : |
| 4989 | break loop32; | 6661 | break loop27; |
| 4990 | } | 6662 | } |
| 4991 | } while (true); | 6663 | } while (true); |
| 4992 | 6664 | ||
| 4993 | otherlv_12=(Token)match(input,19,FOLLOW_2); | ||
| 4994 | |||
| 4995 | newLeafNode(otherlv_12, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); | ||
| 4996 | |||
| 4997 | 6665 | ||
| 4998 | } | 6666 | } |
| 6667 | break; | ||
| 4999 | 6668 | ||
| 6669 | } | ||
| 6670 | |||
| 6671 | otherlv_7=(Token)match(input,LeftCurlyBracket,FOLLOW_41); | ||
| 6672 | |||
| 6673 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | ||
| 6674 | |||
| 6675 | // InternalSolverLanguageParser.g:2592:3: ( (lv_members_8_0= ruleMemberDefinition ) )* | ||
| 6676 | loop29: | ||
| 6677 | do { | ||
| 6678 | int alt29=2; | ||
| 6679 | int LA29_0 = input.LA(1); | ||
| 6680 | |||
| 6681 | if ( (LA29_0==Contains||LA29_0==RULE_QUOTED_ID||LA29_0==RULE_ID) ) { | ||
| 6682 | alt29=1; | ||
| 6683 | } | ||
| 6684 | |||
| 6685 | |||
| 6686 | switch (alt29) { | ||
| 6687 | case 1 : | ||
| 6688 | // InternalSolverLanguageParser.g:2593:4: (lv_members_8_0= ruleMemberDefinition ) | ||
| 6689 | { | ||
| 6690 | // InternalSolverLanguageParser.g:2593:4: (lv_members_8_0= ruleMemberDefinition ) | ||
| 6691 | // InternalSolverLanguageParser.g:2594:5: lv_members_8_0= ruleMemberDefinition | ||
| 6692 | { | ||
| 6693 | |||
| 6694 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
| 6695 | |||
| 6696 | pushFollow(FOLLOW_41); | ||
| 6697 | lv_members_8_0=ruleMemberDefinition(); | ||
| 6698 | |||
| 6699 | state._fsp--; | ||
| 6700 | |||
| 6701 | |||
| 6702 | if (current==null) { | ||
| 6703 | current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); | ||
| 6704 | } | ||
| 6705 | add( | ||
| 6706 | current, | ||
| 6707 | "members", | ||
| 6708 | lv_members_8_0, | ||
| 6709 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); | ||
| 6710 | afterParserOrEnumRuleCall(); | ||
| 6711 | |||
| 6712 | |||
| 6713 | } | ||
| 5000 | 6714 | ||
| 5001 | } | 6715 | |
| 5002 | break; | 6716 | } |
| 6717 | break; | ||
| 6718 | |||
| 6719 | default : | ||
| 6720 | break loop29; | ||
| 6721 | } | ||
| 6722 | } while (true); | ||
| 6723 | |||
| 6724 | otherlv_9=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
| 6725 | |||
| 6726 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | ||
| 6727 | |||
| 5003 | 6728 | ||
| 5004 | } | 6729 | } |
| 5005 | 6730 | ||
| @@ -5019,28 +6744,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5019 | } | 6744 | } |
| 5020 | return current; | 6745 | return current; |
| 5021 | } | 6746 | } |
| 5022 | // $ANTLR end "ruleConstraint" | 6747 | // $ANTLR end "ruleClassDefinition" |
| 5023 | 6748 | ||
| 5024 | 6749 | ||
| 5025 | // $ANTLR start "entryRuleClosureType" | 6750 | // $ANTLR start "entryRuleMemberDefinition" |
| 5026 | // InternalSolverLanguage.g:1730:1: entryRuleClosureType returns [EObject current=null] : iv_ruleClosureType= ruleClosureType EOF ; | 6751 | // InternalSolverLanguageParser.g:2619:1: entryRuleMemberDefinition returns [EObject current=null] : iv_ruleMemberDefinition= ruleMemberDefinition EOF ; |
| 5027 | public final EObject entryRuleClosureType() throws RecognitionException { | 6752 | public final EObject entryRuleMemberDefinition() throws RecognitionException { |
| 5028 | EObject current = null; | 6753 | EObject current = null; |
| 5029 | 6754 | ||
| 5030 | EObject iv_ruleClosureType = null; | 6755 | EObject iv_ruleMemberDefinition = null; |
| 5031 | 6756 | ||
| 5032 | 6757 | ||
| 5033 | try { | 6758 | try { |
| 5034 | // InternalSolverLanguage.g:1730:52: (iv_ruleClosureType= ruleClosureType EOF ) | 6759 | // InternalSolverLanguageParser.g:2619:57: (iv_ruleMemberDefinition= ruleMemberDefinition EOF ) |
| 5035 | // InternalSolverLanguage.g:1731:2: iv_ruleClosureType= ruleClosureType EOF | 6760 | // InternalSolverLanguageParser.g:2620:2: iv_ruleMemberDefinition= ruleMemberDefinition EOF |
| 5036 | { | 6761 | { |
| 5037 | newCompositeNode(grammarAccess.getClosureTypeRule()); | 6762 | newCompositeNode(grammarAccess.getMemberDefinitionRule()); |
| 5038 | pushFollow(FOLLOW_1); | 6763 | pushFollow(FOLLOW_1); |
| 5039 | iv_ruleClosureType=ruleClosureType(); | 6764 | iv_ruleMemberDefinition=ruleMemberDefinition(); |
| 5040 | 6765 | ||
| 5041 | state._fsp--; | 6766 | state._fsp--; |
| 5042 | 6767 | ||
| 5043 | current =iv_ruleClosureType; | 6768 | current =iv_ruleMemberDefinition; |
| 5044 | match(input,EOF,FOLLOW_2); | 6769 | match(input,EOF,FOLLOW_2); |
| 5045 | 6770 | ||
| 5046 | } | 6771 | } |
| @@ -5055,92 +6780,224 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5055 | } | 6780 | } |
| 5056 | return current; | 6781 | return current; |
| 5057 | } | 6782 | } |
| 5058 | // $ANTLR end "entryRuleClosureType" | 6783 | // $ANTLR end "entryRuleMemberDefinition" |
| 5059 | 6784 | ||
| 5060 | 6785 | ||
| 5061 | // $ANTLR start "ruleClosureType" | 6786 | // $ANTLR start "ruleMemberDefinition" |
| 5062 | // InternalSolverLanguage.g:1737:1: ruleClosureType returns [EObject current=null] : ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ; | 6787 | // InternalSolverLanguageParser.g:2626:1: ruleMemberDefinition returns [EObject current=null] : ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) ; |
| 5063 | public final EObject ruleClosureType() throws RecognitionException { | 6788 | public final EObject ruleMemberDefinition() throws RecognitionException { |
| 5064 | EObject current = null; | 6789 | EObject current = null; |
| 5065 | 6790 | ||
| 5066 | Token otherlv_1=null; | 6791 | Token lv_containment_0_0=null; |
| 5067 | Token otherlv_3=null; | 6792 | Token lv_name_3_0=null; |
| 6793 | Token otherlv_4=null; | ||
| 6794 | Token otherlv_6=null; | ||
| 6795 | EObject lv_multiplicity_2_0 = null; | ||
| 6796 | |||
| 5068 | 6797 | ||
| 5069 | 6798 | ||
| 5070 | enterRule(); | 6799 | enterRule(); |
| 5071 | 6800 | ||
| 5072 | try { | 6801 | try { |
| 5073 | // InternalSolverLanguage.g:1743:2: ( ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ) | 6802 | // InternalSolverLanguageParser.g:2632:2: ( ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) ) |
| 5074 | // InternalSolverLanguage.g:1744:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) | 6803 | // InternalSolverLanguageParser.g:2633:2: ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) |
| 5075 | { | 6804 | { |
| 5076 | // InternalSolverLanguage.g:1744:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) | 6805 | // InternalSolverLanguageParser.g:2633:2: ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) |
| 5077 | int alt34=2; | 6806 | // InternalSolverLanguageParser.g:2634:3: ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? |
| 5078 | int LA34_0 = input.LA(1); | 6807 | { |
| 6808 | // InternalSolverLanguageParser.g:2634:3: ( (lv_containment_0_0= Contains ) )? | ||
| 6809 | int alt30=2; | ||
| 6810 | int LA30_0 = input.LA(1); | ||
| 6811 | |||
| 6812 | if ( (LA30_0==Contains) ) { | ||
| 6813 | alt30=1; | ||
| 6814 | } | ||
| 6815 | switch (alt30) { | ||
| 6816 | case 1 : | ||
| 6817 | // InternalSolverLanguageParser.g:2635:4: (lv_containment_0_0= Contains ) | ||
| 6818 | { | ||
| 6819 | // InternalSolverLanguageParser.g:2635:4: (lv_containment_0_0= Contains ) | ||
| 6820 | // InternalSolverLanguageParser.g:2636:5: lv_containment_0_0= Contains | ||
| 6821 | { | ||
| 6822 | lv_containment_0_0=(Token)match(input,Contains,FOLLOW_8); | ||
| 6823 | |||
| 6824 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
| 6825 | |||
| 6826 | |||
| 6827 | if (current==null) { | ||
| 6828 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 6829 | } | ||
| 6830 | setWithLastConsumed(current, "containment", true, "contains"); | ||
| 6831 | |||
| 6832 | |||
| 6833 | } | ||
| 6834 | |||
| 6835 | |||
| 6836 | } | ||
| 6837 | break; | ||
| 6838 | |||
| 6839 | } | ||
| 6840 | |||
| 6841 | // InternalSolverLanguageParser.g:2648:3: ( ( ruleQualifiedName ) ) | ||
| 6842 | // InternalSolverLanguageParser.g:2649:4: ( ruleQualifiedName ) | ||
| 6843 | { | ||
| 6844 | // InternalSolverLanguageParser.g:2649:4: ( ruleQualifiedName ) | ||
| 6845 | // InternalSolverLanguageParser.g:2650:5: ruleQualifiedName | ||
| 6846 | { | ||
| 6847 | |||
| 6848 | if (current==null) { | ||
| 6849 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 6850 | } | ||
| 6851 | |||
| 6852 | |||
| 6853 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
| 6854 | |||
| 6855 | pushFollow(FOLLOW_42); | ||
| 6856 | ruleQualifiedName(); | ||
| 6857 | |||
| 6858 | state._fsp--; | ||
| 6859 | |||
| 6860 | |||
| 6861 | afterParserOrEnumRuleCall(); | ||
| 6862 | |||
| 5079 | 6863 | ||
| 5080 | if ( (LA34_0==31) ) { | ||
| 5081 | alt34=1; | ||
| 5082 | } | 6864 | } |
| 5083 | else if ( (LA34_0==30) ) { | 6865 | |
| 5084 | alt34=2; | 6866 | |
| 5085 | } | 6867 | } |
| 5086 | else { | ||
| 5087 | NoViableAltException nvae = | ||
| 5088 | new NoViableAltException("", 34, 0, input); | ||
| 5089 | 6868 | ||
| 5090 | throw nvae; | 6869 | // InternalSolverLanguageParser.g:2664:3: ( (lv_multiplicity_2_0= ruleMultiplicity ) )? |
| 6870 | int alt31=2; | ||
| 6871 | int LA31_0 = input.LA(1); | ||
| 6872 | |||
| 6873 | if ( (LA31_0==LeftSquareBracket) ) { | ||
| 6874 | alt31=1; | ||
| 5091 | } | 6875 | } |
| 5092 | switch (alt34) { | 6876 | switch (alt31) { |
| 5093 | case 1 : | 6877 | case 1 : |
| 5094 | // InternalSolverLanguage.g:1745:3: ( () otherlv_1= '*' ) | 6878 | // InternalSolverLanguageParser.g:2665:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
| 5095 | { | 6879 | { |
| 5096 | // InternalSolverLanguage.g:1745:3: ( () otherlv_1= '*' ) | 6880 | // InternalSolverLanguageParser.g:2665:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
| 5097 | // InternalSolverLanguage.g:1746:4: () otherlv_1= '*' | 6881 | // InternalSolverLanguageParser.g:2666:5: lv_multiplicity_2_0= ruleMultiplicity |
| 5098 | { | ||
| 5099 | // InternalSolverLanguage.g:1746:4: () | ||
| 5100 | // InternalSolverLanguage.g:1747:5: | ||
| 5101 | { | 6882 | { |
| 5102 | 6883 | ||
| 5103 | current = forceCreateModelElement( | 6884 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); |
| 5104 | grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), | ||
| 5105 | current); | ||
| 5106 | 6885 | ||
| 6886 | pushFollow(FOLLOW_38); | ||
| 6887 | lv_multiplicity_2_0=ruleMultiplicity(); | ||
| 5107 | 6888 | ||
| 5108 | } | 6889 | state._fsp--; |
| 5109 | 6890 | ||
| 5110 | otherlv_1=(Token)match(input,31,FOLLOW_2); | ||
| 5111 | 6891 | ||
| 5112 | newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); | 6892 | if (current==null) { |
| 5113 | 6893 | current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); | |
| 6894 | } | ||
| 6895 | set( | ||
| 6896 | current, | ||
| 6897 | "multiplicity", | ||
| 6898 | lv_multiplicity_2_0, | ||
| 6899 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
| 6900 | afterParserOrEnumRuleCall(); | ||
| 6901 | |||
| 5114 | 6902 | ||
| 5115 | } | 6903 | } |
| 5116 | 6904 | ||
| 5117 | 6905 | ||
| 5118 | } | 6906 | } |
| 5119 | break; | 6907 | break; |
| 5120 | case 2 : | 6908 | |
| 5121 | // InternalSolverLanguage.g:1759:3: ( () otherlv_3= '+' ) | 6909 | } |
| 6910 | |||
| 6911 | // InternalSolverLanguageParser.g:2683:3: ( (lv_name_3_0= RULE_ID ) ) | ||
| 6912 | // InternalSolverLanguageParser.g:2684:4: (lv_name_3_0= RULE_ID ) | ||
| 6913 | { | ||
| 6914 | // InternalSolverLanguageParser.g:2684:4: (lv_name_3_0= RULE_ID ) | ||
| 6915 | // InternalSolverLanguageParser.g:2685:5: lv_name_3_0= RULE_ID | ||
| 6916 | { | ||
| 6917 | lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_43); | ||
| 6918 | |||
| 6919 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | ||
| 6920 | |||
| 6921 | |||
| 6922 | if (current==null) { | ||
| 6923 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | ||
| 6924 | } | ||
| 6925 | setWithLastConsumed( | ||
| 6926 | current, | ||
| 6927 | "name", | ||
| 6928 | lv_name_3_0, | ||
| 6929 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 6930 | |||
| 6931 | |||
| 6932 | } | ||
| 6933 | |||
| 6934 | |||
| 6935 | } | ||
| 6936 | |||
| 6937 | // InternalSolverLanguageParser.g:2701:3: (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? | ||
| 6938 | int alt32=2; | ||
| 6939 | int LA32_0 = input.LA(1); | ||
| 6940 | |||
| 6941 | if ( (LA32_0==Opposite) ) { | ||
| 6942 | alt32=1; | ||
| 6943 | } | ||
| 6944 | switch (alt32) { | ||
| 6945 | case 1 : | ||
| 6946 | // InternalSolverLanguageParser.g:2702:4: otherlv_4= Opposite ( ( ruleQualifiedName ) ) | ||
| 5122 | { | 6947 | { |
| 5123 | // InternalSolverLanguage.g:1759:3: ( () otherlv_3= '+' ) | 6948 | otherlv_4=(Token)match(input,Opposite,FOLLOW_8); |
| 5124 | // InternalSolverLanguage.g:1760:4: () otherlv_3= '+' | 6949 | |
| 6950 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | ||
| 6951 | |||
| 6952 | // InternalSolverLanguageParser.g:2706:4: ( ( ruleQualifiedName ) ) | ||
| 6953 | // InternalSolverLanguageParser.g:2707:5: ( ruleQualifiedName ) | ||
| 5125 | { | 6954 | { |
| 5126 | // InternalSolverLanguage.g:1760:4: () | 6955 | // InternalSolverLanguageParser.g:2707:5: ( ruleQualifiedName ) |
| 5127 | // InternalSolverLanguage.g:1761:5: | 6956 | // InternalSolverLanguageParser.g:2708:6: ruleQualifiedName |
| 5128 | { | 6957 | { |
| 5129 | 6958 | ||
| 5130 | current = forceCreateModelElement( | 6959 | if (current==null) { |
| 5131 | grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), | 6960 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
| 5132 | current); | 6961 | } |
| 5133 | 6962 | ||
| 6963 | |||
| 6964 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | ||
| 6965 | |||
| 6966 | pushFollow(FOLLOW_18); | ||
| 6967 | ruleQualifiedName(); | ||
| 6968 | |||
| 6969 | state._fsp--; | ||
| 6970 | |||
| 6971 | |||
| 6972 | afterParserOrEnumRuleCall(); | ||
| 6973 | |||
| 5134 | 6974 | ||
| 5135 | } | 6975 | } |
| 5136 | 6976 | ||
| 5137 | otherlv_3=(Token)match(input,30,FOLLOW_2); | ||
| 5138 | 6977 | ||
| 5139 | newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); | 6978 | } |
| 5140 | 6979 | ||
| 5141 | 6980 | ||
| 5142 | } | 6981 | } |
| 6982 | break; | ||
| 5143 | 6983 | ||
| 6984 | } | ||
| 6985 | |||
| 6986 | // InternalSolverLanguageParser.g:2723:3: (otherlv_6= Semicolon )? | ||
| 6987 | int alt33=2; | ||
| 6988 | int LA33_0 = input.LA(1); | ||
| 6989 | |||
| 6990 | if ( (LA33_0==Semicolon) ) { | ||
| 6991 | alt33=1; | ||
| 6992 | } | ||
| 6993 | switch (alt33) { | ||
| 6994 | case 1 : | ||
| 6995 | // InternalSolverLanguageParser.g:2724:4: otherlv_6= Semicolon | ||
| 6996 | { | ||
| 6997 | otherlv_6=(Token)match(input,Semicolon,FOLLOW_2); | ||
| 6998 | |||
| 6999 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | ||
| 7000 | |||
| 5144 | 7001 | ||
| 5145 | } | 7002 | } |
| 5146 | break; | 7003 | break; |
| @@ -5151,6 +7008,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5151 | } | 7008 | } |
| 5152 | 7009 | ||
| 5153 | 7010 | ||
| 7011 | } | ||
| 7012 | |||
| 7013 | |||
| 5154 | leaveRule(); | 7014 | leaveRule(); |
| 5155 | 7015 | ||
| 5156 | } | 7016 | } |
| @@ -5163,28 +7023,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5163 | } | 7023 | } |
| 5164 | return current; | 7024 | return current; |
| 5165 | } | 7025 | } |
| 5166 | // $ANTLR end "ruleClosureType" | 7026 | // $ANTLR end "ruleMemberDefinition" |
| 5167 | 7027 | ||
| 5168 | 7028 | ||
| 5169 | // $ANTLR start "entryRuleLiteral" | 7029 | // $ANTLR start "entryRuleMultiplicity" |
| 5170 | // InternalSolverLanguage.g:1776:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; | 7030 | // InternalSolverLanguageParser.g:2733:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; |
| 5171 | public final EObject entryRuleLiteral() throws RecognitionException { | 7031 | public final EObject entryRuleMultiplicity() throws RecognitionException { |
| 5172 | EObject current = null; | 7032 | EObject current = null; |
| 5173 | 7033 | ||
| 5174 | EObject iv_ruleLiteral = null; | 7034 | EObject iv_ruleMultiplicity = null; |
| 5175 | 7035 | ||
| 5176 | 7036 | ||
| 5177 | try { | 7037 | try { |
| 5178 | // InternalSolverLanguage.g:1776:48: (iv_ruleLiteral= ruleLiteral EOF ) | 7038 | // InternalSolverLanguageParser.g:2733:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) |
| 5179 | // InternalSolverLanguage.g:1777:2: iv_ruleLiteral= ruleLiteral EOF | 7039 | // InternalSolverLanguageParser.g:2734:2: iv_ruleMultiplicity= ruleMultiplicity EOF |
| 5180 | { | 7040 | { |
| 5181 | newCompositeNode(grammarAccess.getLiteralRule()); | 7041 | newCompositeNode(grammarAccess.getMultiplicityRule()); |
| 5182 | pushFollow(FOLLOW_1); | 7042 | pushFollow(FOLLOW_1); |
| 5183 | iv_ruleLiteral=ruleLiteral(); | 7043 | iv_ruleMultiplicity=ruleMultiplicity(); |
| 5184 | 7044 | ||
| 5185 | state._fsp--; | 7045 | state._fsp--; |
| 5186 | 7046 | ||
| 5187 | current =iv_ruleLiteral; | 7047 | current =iv_ruleMultiplicity; |
| 5188 | match(input,EOF,FOLLOW_2); | 7048 | match(input,EOF,FOLLOW_2); |
| 5189 | 7049 | ||
| 5190 | } | 7050 | } |
| @@ -5199,107 +7059,126 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5199 | } | 7059 | } |
| 5200 | return current; | 7060 | return current; |
| 5201 | } | 7061 | } |
| 5202 | // $ANTLR end "entryRuleLiteral" | 7062 | // $ANTLR end "entryRuleMultiplicity" |
| 5203 | 7063 | ||
| 5204 | 7064 | ||
| 5205 | // $ANTLR start "ruleLiteral" | 7065 | // $ANTLR start "ruleMultiplicity" |
| 5206 | // InternalSolverLanguage.g:1783:1: ruleLiteral returns [EObject current=null] : (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) ; | 7066 | // InternalSolverLanguageParser.g:2740:1: ruleMultiplicity returns [EObject current=null] : (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ; |
| 5207 | public final EObject ruleLiteral() throws RecognitionException { | 7067 | public final EObject ruleMultiplicity() throws RecognitionException { |
| 5208 | EObject current = null; | 7068 | EObject current = null; |
| 5209 | 7069 | ||
| 5210 | EObject this_Variable_0 = null; | 7070 | EObject this_ManyMultiplicity_0 = null; |
| 5211 | 7071 | ||
| 5212 | EObject this_DataObject_1 = null; | 7072 | EObject this_ExactMultiplicity_1 = null; |
| 5213 | 7073 | ||
| 5214 | EObject this_NamedObject_2 = null; | 7074 | EObject this_BoundedMultiplicity_2 = null; |
| 5215 | 7075 | ||
| 5216 | 7076 | ||
| 5217 | 7077 | ||
| 5218 | enterRule(); | 7078 | enterRule(); |
| 5219 | 7079 | ||
| 5220 | try { | 7080 | try { |
| 5221 | // InternalSolverLanguage.g:1789:2: ( (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) ) | 7081 | // InternalSolverLanguageParser.g:2746:2: ( (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ) |
| 5222 | // InternalSolverLanguage.g:1790:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) | 7082 | // InternalSolverLanguageParser.g:2747:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
| 5223 | { | 7083 | { |
| 5224 | // InternalSolverLanguage.g:1790:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject | this_NamedObject_2= ruleNamedObject ) | 7084 | // InternalSolverLanguageParser.g:2747:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
| 5225 | int alt35=3; | 7085 | int alt34=3; |
| 5226 | switch ( input.LA(1) ) { | 7086 | int LA34_0 = input.LA(1); |
| 5227 | case RULE_ID: | 7087 | |
| 5228 | { | 7088 | if ( (LA34_0==LeftSquareBracket) ) { |
| 5229 | alt35=1; | 7089 | switch ( input.LA(2) ) { |
| 5230 | } | 7090 | case RULE_INT: |
| 5231 | break; | 7091 | { |
| 5232 | case RULE_INT: | 7092 | int LA34_2 = input.LA(3); |
| 5233 | case RULE_STRING: | 7093 | |
| 5234 | case 11: | 7094 | if ( (LA34_2==FullStopFullStop) ) { |
| 5235 | case 13: | 7095 | alt34=3; |
| 5236 | case 14: | 7096 | } |
| 5237 | { | 7097 | else if ( (LA34_2==RightSquareBracket) ) { |
| 5238 | alt35=2; | 7098 | alt34=2; |
| 5239 | } | 7099 | } |
| 5240 | break; | 7100 | else { |
| 5241 | case 27: | 7101 | NoViableAltException nvae = |
| 5242 | { | 7102 | new NoViableAltException("", 34, 2, input); |
| 5243 | alt35=3; | 7103 | |
| 7104 | throw nvae; | ||
| 7105 | } | ||
| 7106 | } | ||
| 7107 | break; | ||
| 7108 | case Asterisk: | ||
| 7109 | { | ||
| 7110 | alt34=2; | ||
| 7111 | } | ||
| 7112 | break; | ||
| 7113 | case RightSquareBracket: | ||
| 7114 | { | ||
| 7115 | alt34=1; | ||
| 7116 | } | ||
| 7117 | break; | ||
| 7118 | default: | ||
| 7119 | NoViableAltException nvae = | ||
| 7120 | new NoViableAltException("", 34, 1, input); | ||
| 7121 | |||
| 7122 | throw nvae; | ||
| 5244 | } | 7123 | } |
| 5245 | break; | 7124 | |
| 5246 | default: | 7125 | } |
| 7126 | else { | ||
| 5247 | NoViableAltException nvae = | 7127 | NoViableAltException nvae = |
| 5248 | new NoViableAltException("", 35, 0, input); | 7128 | new NoViableAltException("", 34, 0, input); |
| 5249 | 7129 | ||
| 5250 | throw nvae; | 7130 | throw nvae; |
| 5251 | } | 7131 | } |
| 5252 | 7132 | switch (alt34) { | |
| 5253 | switch (alt35) { | ||
| 5254 | case 1 : | 7133 | case 1 : |
| 5255 | // InternalSolverLanguage.g:1791:3: this_Variable_0= ruleVariable | 7134 | // InternalSolverLanguageParser.g:2748:3: this_ManyMultiplicity_0= ruleManyMultiplicity |
| 5256 | { | 7135 | { |
| 5257 | 7136 | ||
| 5258 | newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); | 7137 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); |
| 5259 | 7138 | ||
| 5260 | pushFollow(FOLLOW_2); | 7139 | pushFollow(FOLLOW_2); |
| 5261 | this_Variable_0=ruleVariable(); | 7140 | this_ManyMultiplicity_0=ruleManyMultiplicity(); |
| 5262 | 7141 | ||
| 5263 | state._fsp--; | 7142 | state._fsp--; |
| 5264 | 7143 | ||
| 5265 | 7144 | ||
| 5266 | current = this_Variable_0; | 7145 | current = this_ManyMultiplicity_0; |
| 5267 | afterParserOrEnumRuleCall(); | 7146 | afterParserOrEnumRuleCall(); |
| 5268 | 7147 | ||
| 5269 | 7148 | ||
| 5270 | } | 7149 | } |
| 5271 | break; | 7150 | break; |
| 5272 | case 2 : | 7151 | case 2 : |
| 5273 | // InternalSolverLanguage.g:1800:3: this_DataObject_1= ruleDataObject | 7152 | // InternalSolverLanguageParser.g:2757:3: this_ExactMultiplicity_1= ruleExactMultiplicity |
| 5274 | { | 7153 | { |
| 5275 | 7154 | ||
| 5276 | newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); | 7155 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
| 5277 | 7156 | ||
| 5278 | pushFollow(FOLLOW_2); | 7157 | pushFollow(FOLLOW_2); |
| 5279 | this_DataObject_1=ruleDataObject(); | 7158 | this_ExactMultiplicity_1=ruleExactMultiplicity(); |
| 5280 | 7159 | ||
| 5281 | state._fsp--; | 7160 | state._fsp--; |
| 5282 | 7161 | ||
| 5283 | 7162 | ||
| 5284 | current = this_DataObject_1; | 7163 | current = this_ExactMultiplicity_1; |
| 5285 | afterParserOrEnumRuleCall(); | 7164 | afterParserOrEnumRuleCall(); |
| 5286 | 7165 | ||
| 5287 | 7166 | ||
| 5288 | } | 7167 | } |
| 5289 | break; | 7168 | break; |
| 5290 | case 3 : | 7169 | case 3 : |
| 5291 | // InternalSolverLanguage.g:1809:3: this_NamedObject_2= ruleNamedObject | 7170 | // InternalSolverLanguageParser.g:2766:3: this_BoundedMultiplicity_2= ruleBoundedMultiplicity |
| 5292 | { | 7171 | { |
| 5293 | 7172 | ||
| 5294 | newCompositeNode(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); | 7173 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); |
| 5295 | 7174 | ||
| 5296 | pushFollow(FOLLOW_2); | 7175 | pushFollow(FOLLOW_2); |
| 5297 | this_NamedObject_2=ruleNamedObject(); | 7176 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity(); |
| 5298 | 7177 | ||
| 5299 | state._fsp--; | 7178 | state._fsp--; |
| 5300 | 7179 | ||
| 5301 | 7180 | ||
| 5302 | current = this_NamedObject_2; | 7181 | current = this_BoundedMultiplicity_2; |
| 5303 | afterParserOrEnumRuleCall(); | 7182 | afterParserOrEnumRuleCall(); |
| 5304 | 7183 | ||
| 5305 | 7184 | ||
| @@ -5324,28 +7203,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5324 | } | 7203 | } |
| 5325 | return current; | 7204 | return current; |
| 5326 | } | 7205 | } |
| 5327 | // $ANTLR end "ruleLiteral" | 7206 | // $ANTLR end "ruleMultiplicity" |
| 5328 | 7207 | ||
| 5329 | 7208 | ||
| 5330 | // $ANTLR start "entryRuleVariable" | 7209 | // $ANTLR start "entryRuleManyMultiplicity" |
| 5331 | // InternalSolverLanguage.g:1821:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ; | 7210 | // InternalSolverLanguageParser.g:2778:1: entryRuleManyMultiplicity returns [EObject current=null] : iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ; |
| 5332 | public final EObject entryRuleVariable() throws RecognitionException { | 7211 | public final EObject entryRuleManyMultiplicity() throws RecognitionException { |
| 5333 | EObject current = null; | 7212 | EObject current = null; |
| 5334 | 7213 | ||
| 5335 | EObject iv_ruleVariable = null; | 7214 | EObject iv_ruleManyMultiplicity = null; |
| 5336 | 7215 | ||
| 5337 | 7216 | ||
| 5338 | try { | 7217 | try { |
| 5339 | // InternalSolverLanguage.g:1821:49: (iv_ruleVariable= ruleVariable EOF ) | 7218 | // InternalSolverLanguageParser.g:2778:57: (iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ) |
| 5340 | // InternalSolverLanguage.g:1822:2: iv_ruleVariable= ruleVariable EOF | 7219 | // InternalSolverLanguageParser.g:2779:2: iv_ruleManyMultiplicity= ruleManyMultiplicity EOF |
| 5341 | { | 7220 | { |
| 5342 | newCompositeNode(grammarAccess.getVariableRule()); | 7221 | newCompositeNode(grammarAccess.getManyMultiplicityRule()); |
| 5343 | pushFollow(FOLLOW_1); | 7222 | pushFollow(FOLLOW_1); |
| 5344 | iv_ruleVariable=ruleVariable(); | 7223 | iv_ruleManyMultiplicity=ruleManyMultiplicity(); |
| 5345 | 7224 | ||
| 5346 | state._fsp--; | 7225 | state._fsp--; |
| 5347 | 7226 | ||
| 5348 | current =iv_ruleVariable; | 7227 | current =iv_ruleManyMultiplicity; |
| 5349 | match(input,EOF,FOLLOW_2); | 7228 | match(input,EOF,FOLLOW_2); |
| 5350 | 7229 | ||
| 5351 | } | 7230 | } |
| @@ -5360,46 +7239,46 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5360 | } | 7239 | } |
| 5361 | return current; | 7240 | return current; |
| 5362 | } | 7241 | } |
| 5363 | // $ANTLR end "entryRuleVariable" | 7242 | // $ANTLR end "entryRuleManyMultiplicity" |
| 5364 | 7243 | ||
| 5365 | 7244 | ||
| 5366 | // $ANTLR start "ruleVariable" | 7245 | // $ANTLR start "ruleManyMultiplicity" |
| 5367 | // InternalSolverLanguage.g:1828:1: ruleVariable returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | 7246 | // InternalSolverLanguageParser.g:2785:1: ruleManyMultiplicity returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ; |
| 5368 | public final EObject ruleVariable() throws RecognitionException { | 7247 | public final EObject ruleManyMultiplicity() throws RecognitionException { |
| 5369 | EObject current = null; | 7248 | EObject current = null; |
| 5370 | 7249 | ||
| 5371 | Token lv_name_0_0=null; | 7250 | Token otherlv_1=null; |
| 7251 | Token otherlv_2=null; | ||
| 5372 | 7252 | ||
| 5373 | 7253 | ||
| 5374 | enterRule(); | 7254 | enterRule(); |
| 5375 | 7255 | ||
| 5376 | try { | 7256 | try { |
| 5377 | // InternalSolverLanguage.g:1834:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | 7257 | // InternalSolverLanguageParser.g:2791:2: ( ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ) |
| 5378 | // InternalSolverLanguage.g:1835:2: ( (lv_name_0_0= RULE_ID ) ) | 7258 | // InternalSolverLanguageParser.g:2792:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) |
| 5379 | { | 7259 | { |
| 5380 | // InternalSolverLanguage.g:1835:2: ( (lv_name_0_0= RULE_ID ) ) | 7260 | // InternalSolverLanguageParser.g:2792:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) |
| 5381 | // InternalSolverLanguage.g:1836:3: (lv_name_0_0= RULE_ID ) | 7261 | // InternalSolverLanguageParser.g:2793:3: () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket |
| 5382 | { | 7262 | { |
| 5383 | // InternalSolverLanguage.g:1836:3: (lv_name_0_0= RULE_ID ) | 7263 | // InternalSolverLanguageParser.g:2793:3: () |
| 5384 | // InternalSolverLanguage.g:1837:4: lv_name_0_0= RULE_ID | 7264 | // InternalSolverLanguageParser.g:2794:4: |
| 5385 | { | 7265 | { |
| 5386 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
| 5387 | |||
| 5388 | newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); | ||
| 5389 | |||
| 5390 | 7266 | ||
| 5391 | if (current==null) { | 7267 | current = forceCreateModelElement( |
| 5392 | current = createModelElement(grammarAccess.getVariableRule()); | 7268 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), |
| 5393 | } | 7269 | current); |
| 5394 | setWithLastConsumed( | ||
| 5395 | current, | ||
| 5396 | "name", | ||
| 5397 | lv_name_0_0, | ||
| 5398 | "org.eclipse.xtext.common.Terminals.ID"); | ||
| 5399 | 7270 | ||
| 5400 | 7271 | ||
| 5401 | } | 7272 | } |
| 5402 | 7273 | ||
| 7274 | otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_36); | ||
| 7275 | |||
| 7276 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
| 7277 | |||
| 7278 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
| 7279 | |||
| 7280 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 7281 | |||
| 5403 | 7282 | ||
| 5404 | } | 7283 | } |
| 5405 | 7284 | ||
| @@ -5419,28 +7298,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5419 | } | 7298 | } |
| 5420 | return current; | 7299 | return current; |
| 5421 | } | 7300 | } |
| 5422 | // $ANTLR end "ruleVariable" | 7301 | // $ANTLR end "ruleManyMultiplicity" |
| 5423 | 7302 | ||
| 5424 | 7303 | ||
| 5425 | // $ANTLR start "entryRuleAllInstances" | 7304 | // $ANTLR start "entryRuleExactMultiplicity" |
| 5426 | // InternalSolverLanguage.g:1856:1: entryRuleAllInstances returns [EObject current=null] : iv_ruleAllInstances= ruleAllInstances EOF ; | 7305 | // InternalSolverLanguageParser.g:2812:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; |
| 5427 | public final EObject entryRuleAllInstances() throws RecognitionException { | 7306 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { |
| 5428 | EObject current = null; | 7307 | EObject current = null; |
| 5429 | 7308 | ||
| 5430 | EObject iv_ruleAllInstances = null; | 7309 | EObject iv_ruleExactMultiplicity = null; |
| 5431 | 7310 | ||
| 5432 | 7311 | ||
| 5433 | try { | 7312 | try { |
| 5434 | // InternalSolverLanguage.g:1856:53: (iv_ruleAllInstances= ruleAllInstances EOF ) | 7313 | // InternalSolverLanguageParser.g:2812:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) |
| 5435 | // InternalSolverLanguage.g:1857:2: iv_ruleAllInstances= ruleAllInstances EOF | 7314 | // InternalSolverLanguageParser.g:2813:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF |
| 5436 | { | 7315 | { |
| 5437 | newCompositeNode(grammarAccess.getAllInstancesRule()); | 7316 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); |
| 5438 | pushFollow(FOLLOW_1); | 7317 | pushFollow(FOLLOW_1); |
| 5439 | iv_ruleAllInstances=ruleAllInstances(); | 7318 | iv_ruleExactMultiplicity=ruleExactMultiplicity(); |
| 5440 | 7319 | ||
| 5441 | state._fsp--; | 7320 | state._fsp--; |
| 5442 | 7321 | ||
| 5443 | current =iv_ruleAllInstances; | 7322 | current =iv_ruleExactMultiplicity; |
| 5444 | match(input,EOF,FOLLOW_2); | 7323 | match(input,EOF,FOLLOW_2); |
| 5445 | 7324 | ||
| 5446 | } | 7325 | } |
| @@ -5455,55 +7334,56 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5455 | } | 7334 | } |
| 5456 | return current; | 7335 | return current; |
| 5457 | } | 7336 | } |
| 5458 | // $ANTLR end "entryRuleAllInstances" | 7337 | // $ANTLR end "entryRuleExactMultiplicity" |
| 5459 | 7338 | ||
| 5460 | 7339 | ||
| 5461 | // $ANTLR start "ruleAllInstances" | 7340 | // $ANTLR start "ruleExactMultiplicity" |
| 5462 | // InternalSolverLanguage.g:1863:1: ruleAllInstances returns [EObject current=null] : (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ; | 7341 | // InternalSolverLanguageParser.g:2819:1: ruleExactMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ; |
| 5463 | public final EObject ruleAllInstances() throws RecognitionException { | 7342 | public final EObject ruleExactMultiplicity() throws RecognitionException { |
| 5464 | EObject current = null; | 7343 | EObject current = null; |
| 5465 | 7344 | ||
| 5466 | Token otherlv_0=null; | 7345 | Token otherlv_0=null; |
| 5467 | EObject lv_symbol_1_0 = null; | 7346 | Token otherlv_2=null; |
| 7347 | AntlrDatatypeRuleToken lv_multiplicity_1_0 = null; | ||
| 5468 | 7348 | ||
| 5469 | 7349 | ||
| 5470 | 7350 | ||
| 5471 | enterRule(); | 7351 | enterRule(); |
| 5472 | 7352 | ||
| 5473 | try { | 7353 | try { |
| 5474 | // InternalSolverLanguage.g:1869:2: ( (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ) | 7354 | // InternalSolverLanguageParser.g:2825:2: ( (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ) |
| 5475 | // InternalSolverLanguage.g:1870:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) | 7355 | // InternalSolverLanguageParser.g:2826:2: (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) |
| 5476 | { | 7356 | { |
| 5477 | // InternalSolverLanguage.g:1870:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) | 7357 | // InternalSolverLanguageParser.g:2826:2: (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) |
| 5478 | // InternalSolverLanguage.g:1871:3: otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) | 7358 | // InternalSolverLanguageParser.g:2827:3: otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket |
| 5479 | { | 7359 | { |
| 5480 | otherlv_0=(Token)match(input,20,FOLLOW_21); | 7360 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_44); |
| 5481 | 7361 | ||
| 5482 | newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); | 7362 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
| 5483 | 7363 | ||
| 5484 | // InternalSolverLanguage.g:1875:3: ( (lv_symbol_1_0= ruleSymbol ) ) | 7364 | // InternalSolverLanguageParser.g:2831:3: ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) |
| 5485 | // InternalSolverLanguage.g:1876:4: (lv_symbol_1_0= ruleSymbol ) | 7365 | // InternalSolverLanguageParser.g:2832:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) |
| 5486 | { | 7366 | { |
| 5487 | // InternalSolverLanguage.g:1876:4: (lv_symbol_1_0= ruleSymbol ) | 7367 | // InternalSolverLanguageParser.g:2832:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) |
| 5488 | // InternalSolverLanguage.g:1877:5: lv_symbol_1_0= ruleSymbol | 7368 | // InternalSolverLanguageParser.g:2833:5: lv_multiplicity_1_0= ruleUpperMultiplicty |
| 5489 | { | 7369 | { |
| 5490 | 7370 | ||
| 5491 | newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); | 7371 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
| 5492 | 7372 | ||
| 5493 | pushFollow(FOLLOW_2); | 7373 | pushFollow(FOLLOW_36); |
| 5494 | lv_symbol_1_0=ruleSymbol(); | 7374 | lv_multiplicity_1_0=ruleUpperMultiplicty(); |
| 5495 | 7375 | ||
| 5496 | state._fsp--; | 7376 | state._fsp--; |
| 5497 | 7377 | ||
| 5498 | 7378 | ||
| 5499 | if (current==null) { | 7379 | if (current==null) { |
| 5500 | current = createModelElementForParent(grammarAccess.getAllInstancesRule()); | 7380 | current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); |
| 5501 | } | 7381 | } |
| 5502 | set( | 7382 | set( |
| 5503 | current, | 7383 | current, |
| 5504 | "symbol", | 7384 | "multiplicity", |
| 5505 | lv_symbol_1_0, | 7385 | lv_multiplicity_1_0, |
| 5506 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 7386 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); |
| 5507 | afterParserOrEnumRuleCall(); | 7387 | afterParserOrEnumRuleCall(); |
| 5508 | 7388 | ||
| 5509 | 7389 | ||
| @@ -5512,6 +7392,10 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5512 | 7392 | ||
| 5513 | } | 7393 | } |
| 5514 | 7394 | ||
| 7395 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
| 7396 | |||
| 7397 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
| 7398 | |||
| 5515 | 7399 | ||
| 5516 | } | 7400 | } |
| 5517 | 7401 | ||
| @@ -5531,28 +7415,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5531 | } | 7415 | } |
| 5532 | return current; | 7416 | return current; |
| 5533 | } | 7417 | } |
| 5534 | // $ANTLR end "ruleAllInstances" | 7418 | // $ANTLR end "ruleExactMultiplicity" |
| 5535 | 7419 | ||
| 5536 | 7420 | ||
| 5537 | // $ANTLR start "entryRuleAllObjects" | 7421 | // $ANTLR start "entryRuleBoundedMultiplicity" |
| 5538 | // InternalSolverLanguage.g:1898:1: entryRuleAllObjects returns [EObject current=null] : iv_ruleAllObjects= ruleAllObjects EOF ; | 7422 | // InternalSolverLanguageParser.g:2858:1: entryRuleBoundedMultiplicity returns [EObject current=null] : iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ; |
| 5539 | public final EObject entryRuleAllObjects() throws RecognitionException { | 7423 | public final EObject entryRuleBoundedMultiplicity() throws RecognitionException { |
| 5540 | EObject current = null; | 7424 | EObject current = null; |
| 5541 | 7425 | ||
| 5542 | EObject iv_ruleAllObjects = null; | 7426 | EObject iv_ruleBoundedMultiplicity = null; |
| 5543 | 7427 | ||
| 5544 | 7428 | ||
| 5545 | try { | 7429 | try { |
| 5546 | // InternalSolverLanguage.g:1898:51: (iv_ruleAllObjects= ruleAllObjects EOF ) | 7430 | // InternalSolverLanguageParser.g:2858:60: (iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ) |
| 5547 | // InternalSolverLanguage.g:1899:2: iv_ruleAllObjects= ruleAllObjects EOF | 7431 | // InternalSolverLanguageParser.g:2859:2: iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF |
| 5548 | { | 7432 | { |
| 5549 | newCompositeNode(grammarAccess.getAllObjectsRule()); | 7433 | newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); |
| 5550 | pushFollow(FOLLOW_1); | 7434 | pushFollow(FOLLOW_1); |
| 5551 | iv_ruleAllObjects=ruleAllObjects(); | 7435 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity(); |
| 5552 | 7436 | ||
| 5553 | state._fsp--; | 7437 | state._fsp--; |
| 5554 | 7438 | ||
| 5555 | current =iv_ruleAllObjects; | 7439 | current =iv_ruleBoundedMultiplicity; |
| 5556 | match(input,EOF,FOLLOW_2); | 7440 | match(input,EOF,FOLLOW_2); |
| 5557 | 7441 | ||
| 5558 | } | 7442 | } |
| @@ -5567,40 +7451,99 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5567 | } | 7451 | } |
| 5568 | return current; | 7452 | return current; |
| 5569 | } | 7453 | } |
| 5570 | // $ANTLR end "entryRuleAllObjects" | 7454 | // $ANTLR end "entryRuleBoundedMultiplicity" |
| 5571 | 7455 | ||
| 5572 | 7456 | ||
| 5573 | // $ANTLR start "ruleAllObjects" | 7457 | // $ANTLR start "ruleBoundedMultiplicity" |
| 5574 | // InternalSolverLanguage.g:1905:1: ruleAllObjects returns [EObject current=null] : ( () otherlv_1= '*' ) ; | 7458 | // InternalSolverLanguageParser.g:2865:1: ruleBoundedMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ; |
| 5575 | public final EObject ruleAllObjects() throws RecognitionException { | 7459 | public final EObject ruleBoundedMultiplicity() throws RecognitionException { |
| 5576 | EObject current = null; | 7460 | EObject current = null; |
| 5577 | 7461 | ||
| 5578 | Token otherlv_1=null; | 7462 | Token otherlv_0=null; |
| 7463 | Token lv_lowerBound_1_0=null; | ||
| 7464 | Token otherlv_2=null; | ||
| 7465 | Token otherlv_4=null; | ||
| 7466 | AntlrDatatypeRuleToken lv_upperBound_3_0 = null; | ||
| 7467 | |||
| 5579 | 7468 | ||
| 5580 | 7469 | ||
| 5581 | enterRule(); | 7470 | enterRule(); |
| 5582 | 7471 | ||
| 5583 | try { | 7472 | try { |
| 5584 | // InternalSolverLanguage.g:1911:2: ( ( () otherlv_1= '*' ) ) | 7473 | // InternalSolverLanguageParser.g:2871:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ) |
| 5585 | // InternalSolverLanguage.g:1912:2: ( () otherlv_1= '*' ) | 7474 | // InternalSolverLanguageParser.g:2872:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) |
| 5586 | { | 7475 | { |
| 5587 | // InternalSolverLanguage.g:1912:2: ( () otherlv_1= '*' ) | 7476 | // InternalSolverLanguageParser.g:2872:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) |
| 5588 | // InternalSolverLanguage.g:1913:3: () otherlv_1= '*' | 7477 | // InternalSolverLanguageParser.g:2873:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket |
| 5589 | { | 7478 | { |
| 5590 | // InternalSolverLanguage.g:1913:3: () | 7479 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_45); |
| 5591 | // InternalSolverLanguage.g:1914:4: | 7480 | |
| 7481 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
| 7482 | |||
| 7483 | // InternalSolverLanguageParser.g:2877:3: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
| 7484 | // InternalSolverLanguageParser.g:2878:4: (lv_lowerBound_1_0= RULE_INT ) | ||
| 5592 | { | 7485 | { |
| 7486 | // InternalSolverLanguageParser.g:2878:4: (lv_lowerBound_1_0= RULE_INT ) | ||
| 7487 | // InternalSolverLanguageParser.g:2879:5: lv_lowerBound_1_0= RULE_INT | ||
| 7488 | { | ||
| 7489 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_35); | ||
| 7490 | |||
| 7491 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | ||
| 7492 | |||
| 7493 | |||
| 7494 | if (current==null) { | ||
| 7495 | current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
| 7496 | } | ||
| 7497 | setWithLastConsumed( | ||
| 7498 | current, | ||
| 7499 | "lowerBound", | ||
| 7500 | lv_lowerBound_1_0, | ||
| 7501 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 7502 | |||
| 7503 | |||
| 7504 | } | ||
| 5593 | 7505 | ||
| 5594 | current = forceCreateModelElement( | ||
| 5595 | grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), | ||
| 5596 | current); | ||
| 5597 | |||
| 5598 | 7506 | ||
| 5599 | } | 7507 | } |
| 5600 | 7508 | ||
| 5601 | otherlv_1=(Token)match(input,31,FOLLOW_2); | 7509 | otherlv_2=(Token)match(input,FullStopFullStop,FOLLOW_44); |
| 5602 | 7510 | ||
| 5603 | newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); | 7511 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); |
| 7512 | |||
| 7513 | // InternalSolverLanguageParser.g:2899:3: ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) | ||
| 7514 | // InternalSolverLanguageParser.g:2900:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
| 7515 | { | ||
| 7516 | // InternalSolverLanguageParser.g:2900:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
| 7517 | // InternalSolverLanguageParser.g:2901:5: lv_upperBound_3_0= ruleUpperMultiplicty | ||
| 7518 | { | ||
| 7519 | |||
| 7520 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
| 7521 | |||
| 7522 | pushFollow(FOLLOW_36); | ||
| 7523 | lv_upperBound_3_0=ruleUpperMultiplicty(); | ||
| 7524 | |||
| 7525 | state._fsp--; | ||
| 7526 | |||
| 7527 | |||
| 7528 | if (current==null) { | ||
| 7529 | current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
| 7530 | } | ||
| 7531 | set( | ||
| 7532 | current, | ||
| 7533 | "upperBound", | ||
| 7534 | lv_upperBound_3_0, | ||
| 7535 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
| 7536 | afterParserOrEnumRuleCall(); | ||
| 7537 | |||
| 7538 | |||
| 7539 | } | ||
| 7540 | |||
| 7541 | |||
| 7542 | } | ||
| 7543 | |||
| 7544 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
| 7545 | |||
| 7546 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
| 5604 | 7547 | ||
| 5605 | 7548 | ||
| 5606 | } | 7549 | } |
| @@ -5621,28 +7564,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5621 | } | 7564 | } |
| 5622 | return current; | 7565 | return current; |
| 5623 | } | 7566 | } |
| 5624 | // $ANTLR end "ruleAllObjects" | 7567 | // $ANTLR end "ruleBoundedMultiplicity" |
| 5625 | 7568 | ||
| 5626 | 7569 | ||
| 5627 | // $ANTLR start "entryRuleDefaultInterpretation" | 7570 | // $ANTLR start "entryRuleScopeDefinition" |
| 5628 | // InternalSolverLanguage.g:1928:1: entryRuleDefaultInterpretation returns [EObject current=null] : iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ; | 7571 | // InternalSolverLanguageParser.g:2926:1: entryRuleScopeDefinition returns [EObject current=null] : iv_ruleScopeDefinition= ruleScopeDefinition EOF ; |
| 5629 | public final EObject entryRuleDefaultInterpretation() throws RecognitionException { | 7572 | public final EObject entryRuleScopeDefinition() throws RecognitionException { |
| 5630 | EObject current = null; | 7573 | EObject current = null; |
| 5631 | 7574 | ||
| 5632 | EObject iv_ruleDefaultInterpretation = null; | 7575 | EObject iv_ruleScopeDefinition = null; |
| 5633 | 7576 | ||
| 5634 | 7577 | ||
| 5635 | try { | 7578 | try { |
| 5636 | // InternalSolverLanguage.g:1928:62: (iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ) | 7579 | // InternalSolverLanguageParser.g:2926:56: (iv_ruleScopeDefinition= ruleScopeDefinition EOF ) |
| 5637 | // InternalSolverLanguage.g:1929:2: iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF | 7580 | // InternalSolverLanguageParser.g:2927:2: iv_ruleScopeDefinition= ruleScopeDefinition EOF |
| 5638 | { | 7581 | { |
| 5639 | newCompositeNode(grammarAccess.getDefaultInterpretationRule()); | 7582 | newCompositeNode(grammarAccess.getScopeDefinitionRule()); |
| 5640 | pushFollow(FOLLOW_1); | 7583 | pushFollow(FOLLOW_1); |
| 5641 | iv_ruleDefaultInterpretation=ruleDefaultInterpretation(); | 7584 | iv_ruleScopeDefinition=ruleScopeDefinition(); |
| 5642 | 7585 | ||
| 5643 | state._fsp--; | 7586 | state._fsp--; |
| 5644 | 7587 | ||
| 5645 | current =iv_ruleDefaultInterpretation; | 7588 | current =iv_ruleScopeDefinition; |
| 5646 | match(input,EOF,FOLLOW_2); | 7589 | match(input,EOF,FOLLOW_2); |
| 5647 | 7590 | ||
| 5648 | } | 7591 | } |
| @@ -5657,56 +7600,218 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5657 | } | 7600 | } |
| 5658 | return current; | 7601 | return current; |
| 5659 | } | 7602 | } |
| 5660 | // $ANTLR end "entryRuleDefaultInterpretation" | 7603 | // $ANTLR end "entryRuleScopeDefinition" |
| 5661 | 7604 | ||
| 5662 | 7605 | ||
| 5663 | // $ANTLR start "ruleDefaultInterpretation" | 7606 | // $ANTLR start "ruleScopeDefinition" |
| 5664 | // InternalSolverLanguage.g:1935:1: ruleDefaultInterpretation returns [EObject current=null] : (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ; | 7607 | // InternalSolverLanguageParser.g:2933:1: ruleScopeDefinition returns [EObject current=null] : (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ; |
| 5665 | public final EObject ruleDefaultInterpretation() throws RecognitionException { | 7608 | public final EObject ruleScopeDefinition() throws RecognitionException { |
| 5666 | EObject current = null; | 7609 | EObject current = null; |
| 5667 | 7610 | ||
| 5668 | Token otherlv_0=null; | 7611 | EObject this_ExactScopeDefinition_0 = null; |
| 5669 | EObject lv_interpretation_1_0 = null; | 7612 | |
| 7613 | EObject this_BoundedScopeDefinition_1 = null; | ||
| 7614 | |||
| 7615 | EObject this_LowerBoundedScopeDefinition_2 = null; | ||
| 5670 | 7616 | ||
| 5671 | 7617 | ||
| 5672 | 7618 | ||
| 5673 | enterRule(); | 7619 | enterRule(); |
| 5674 | 7620 | ||
| 5675 | try { | 7621 | try { |
| 5676 | // InternalSolverLanguage.g:1941:2: ( (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ) | 7622 | // InternalSolverLanguageParser.g:2939:2: ( (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ) |
| 5677 | // InternalSolverLanguage.g:1942:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) | 7623 | // InternalSolverLanguageParser.g:2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) |
| 5678 | { | 7624 | { |
| 5679 | // InternalSolverLanguage.g:1942:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) | 7625 | // InternalSolverLanguageParser.g:2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) |
| 5680 | // InternalSolverLanguage.g:1943:3: otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) | 7626 | int alt35=3; |
| 7627 | alt35 = dfa35.predict(input); | ||
| 7628 | switch (alt35) { | ||
| 7629 | case 1 : | ||
| 7630 | // InternalSolverLanguageParser.g:2941:3: this_ExactScopeDefinition_0= ruleExactScopeDefinition | ||
| 7631 | { | ||
| 7632 | |||
| 7633 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
| 7634 | |||
| 7635 | pushFollow(FOLLOW_2); | ||
| 7636 | this_ExactScopeDefinition_0=ruleExactScopeDefinition(); | ||
| 7637 | |||
| 7638 | state._fsp--; | ||
| 7639 | |||
| 7640 | |||
| 7641 | current = this_ExactScopeDefinition_0; | ||
| 7642 | afterParserOrEnumRuleCall(); | ||
| 7643 | |||
| 7644 | |||
| 7645 | } | ||
| 7646 | break; | ||
| 7647 | case 2 : | ||
| 7648 | // InternalSolverLanguageParser.g:2950:3: this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | ||
| 7649 | { | ||
| 7650 | |||
| 7651 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
| 7652 | |||
| 7653 | pushFollow(FOLLOW_2); | ||
| 7654 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition(); | ||
| 7655 | |||
| 7656 | state._fsp--; | ||
| 7657 | |||
| 7658 | |||
| 7659 | current = this_BoundedScopeDefinition_1; | ||
| 7660 | afterParserOrEnumRuleCall(); | ||
| 7661 | |||
| 7662 | |||
| 7663 | } | ||
| 7664 | break; | ||
| 7665 | case 3 : | ||
| 7666 | // InternalSolverLanguageParser.g:2959:3: this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition | ||
| 7667 | { | ||
| 7668 | |||
| 7669 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
| 7670 | |||
| 7671 | pushFollow(FOLLOW_2); | ||
| 7672 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition(); | ||
| 7673 | |||
| 7674 | state._fsp--; | ||
| 7675 | |||
| 7676 | |||
| 7677 | current = this_LowerBoundedScopeDefinition_2; | ||
| 7678 | afterParserOrEnumRuleCall(); | ||
| 7679 | |||
| 7680 | |||
| 7681 | } | ||
| 7682 | break; | ||
| 7683 | |||
| 7684 | } | ||
| 7685 | |||
| 7686 | |||
| 7687 | } | ||
| 7688 | |||
| 7689 | |||
| 7690 | leaveRule(); | ||
| 7691 | |||
| 7692 | } | ||
| 7693 | |||
| 7694 | catch (RecognitionException re) { | ||
| 7695 | recover(input,re); | ||
| 7696 | appendSkippedTokens(); | ||
| 7697 | } | ||
| 7698 | finally { | ||
| 7699 | } | ||
| 7700 | return current; | ||
| 7701 | } | ||
| 7702 | // $ANTLR end "ruleScopeDefinition" | ||
| 7703 | |||
| 7704 | |||
| 7705 | // $ANTLR start "entryRuleExactScopeDefinition" | ||
| 7706 | // InternalSolverLanguageParser.g:2971:1: entryRuleExactScopeDefinition returns [EObject current=null] : iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ; | ||
| 7707 | public final EObject entryRuleExactScopeDefinition() throws RecognitionException { | ||
| 7708 | EObject current = null; | ||
| 7709 | |||
| 7710 | EObject iv_ruleExactScopeDefinition = null; | ||
| 7711 | |||
| 7712 | |||
| 7713 | try { | ||
| 7714 | // InternalSolverLanguageParser.g:2971:61: (iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ) | ||
| 7715 | // InternalSolverLanguageParser.g:2972:2: iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF | ||
| 5681 | { | 7716 | { |
| 5682 | otherlv_0=(Token)match(input,32,FOLLOW_21); | 7717 | newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); |
| 7718 | pushFollow(FOLLOW_1); | ||
| 7719 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition(); | ||
| 7720 | |||
| 7721 | state._fsp--; | ||
| 7722 | |||
| 7723 | current =iv_ruleExactScopeDefinition; | ||
| 7724 | match(input,EOF,FOLLOW_2); | ||
| 7725 | |||
| 7726 | } | ||
| 7727 | |||
| 7728 | } | ||
| 7729 | |||
| 7730 | catch (RecognitionException re) { | ||
| 7731 | recover(input,re); | ||
| 7732 | appendSkippedTokens(); | ||
| 7733 | } | ||
| 7734 | finally { | ||
| 7735 | } | ||
| 7736 | return current; | ||
| 7737 | } | ||
| 7738 | // $ANTLR end "entryRuleExactScopeDefinition" | ||
| 5683 | 7739 | ||
| 5684 | newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); | 7740 | |
| 7741 | // $ANTLR start "ruleExactScopeDefinition" | ||
| 7742 | // InternalSolverLanguageParser.g:2978:1: ruleExactScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) ; | ||
| 7743 | public final EObject ruleExactScopeDefinition() throws RecognitionException { | ||
| 7744 | EObject current = null; | ||
| 7745 | |||
| 7746 | Token otherlv_0=null; | ||
| 7747 | Token otherlv_2=null; | ||
| 7748 | Token lv_exactScope_3_0=null; | ||
| 7749 | |||
| 7750 | |||
| 7751 | enterRule(); | ||
| 7752 | |||
| 7753 | try { | ||
| 7754 | // InternalSolverLanguageParser.g:2984:2: ( (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) ) | ||
| 7755 | // InternalSolverLanguageParser.g:2985:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) | ||
| 7756 | { | ||
| 7757 | // InternalSolverLanguageParser.g:2985:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) | ||
| 7758 | // InternalSolverLanguageParser.g:2986:3: otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) | ||
| 7759 | { | ||
| 7760 | otherlv_0=(Token)match(input,Scope,FOLLOW_8); | ||
| 7761 | |||
| 7762 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | ||
| 5685 | 7763 | ||
| 5686 | // InternalSolverLanguage.g:1947:3: ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) | 7764 | // InternalSolverLanguageParser.g:2990:3: ( ( ruleQualifiedName ) ) |
| 5687 | // InternalSolverLanguage.g:1948:4: (lv_interpretation_1_0= ruleBasicInterpretation ) | 7765 | // InternalSolverLanguageParser.g:2991:4: ( ruleQualifiedName ) |
| 5688 | { | 7766 | { |
| 5689 | // InternalSolverLanguage.g:1948:4: (lv_interpretation_1_0= ruleBasicInterpretation ) | 7767 | // InternalSolverLanguageParser.g:2991:4: ( ruleQualifiedName ) |
| 5690 | // InternalSolverLanguage.g:1949:5: lv_interpretation_1_0= ruleBasicInterpretation | 7768 | // InternalSolverLanguageParser.g:2992:5: ruleQualifiedName |
| 5691 | { | 7769 | { |
| 5692 | 7770 | ||
| 5693 | newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); | 7771 | if (current==null) { |
| 7772 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | ||
| 7773 | } | ||
| 5694 | 7774 | ||
| 5695 | pushFollow(FOLLOW_2); | 7775 | |
| 5696 | lv_interpretation_1_0=ruleBasicInterpretation(); | 7776 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
| 7777 | |||
| 7778 | pushFollow(FOLLOW_46); | ||
| 7779 | ruleQualifiedName(); | ||
| 5697 | 7780 | ||
| 5698 | state._fsp--; | 7781 | state._fsp--; |
| 5699 | 7782 | ||
| 5700 | 7783 | ||
| 7784 | afterParserOrEnumRuleCall(); | ||
| 7785 | |||
| 7786 | |||
| 7787 | } | ||
| 7788 | |||
| 7789 | |||
| 7790 | } | ||
| 7791 | |||
| 7792 | otherlv_2=(Token)match(input,EqualsSignEqualsSign,FOLLOW_45); | ||
| 7793 | |||
| 7794 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | ||
| 7795 | |||
| 7796 | // InternalSolverLanguageParser.g:3010:3: ( (lv_exactScope_3_0= RULE_INT ) ) | ||
| 7797 | // InternalSolverLanguageParser.g:3011:4: (lv_exactScope_3_0= RULE_INT ) | ||
| 7798 | { | ||
| 7799 | // InternalSolverLanguageParser.g:3011:4: (lv_exactScope_3_0= RULE_INT ) | ||
| 7800 | // InternalSolverLanguageParser.g:3012:5: lv_exactScope_3_0= RULE_INT | ||
| 7801 | { | ||
| 7802 | lv_exactScope_3_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
| 7803 | |||
| 7804 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | ||
| 7805 | |||
| 7806 | |||
| 5701 | if (current==null) { | 7807 | if (current==null) { |
| 5702 | current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); | 7808 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); |
| 5703 | } | 7809 | } |
| 5704 | set( | 7810 | setWithLastConsumed( |
| 5705 | current, | 7811 | current, |
| 5706 | "interpretation", | 7812 | "exactScope", |
| 5707 | lv_interpretation_1_0, | 7813 | lv_exactScope_3_0, |
| 5708 | "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | 7814 | "org.eclipse.xtext.common.Terminals.INT"); |
| 5709 | afterParserOrEnumRuleCall(); | ||
| 5710 | 7815 | ||
| 5711 | 7816 | ||
| 5712 | } | 7817 | } |
| @@ -5733,28 +7838,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5733 | } | 7838 | } |
| 5734 | return current; | 7839 | return current; |
| 5735 | } | 7840 | } |
| 5736 | // $ANTLR end "ruleDefaultInterpretation" | 7841 | // $ANTLR end "ruleExactScopeDefinition" |
| 5737 | 7842 | ||
| 5738 | 7843 | ||
| 5739 | // $ANTLR start "entryRuleCDInterpretation" | 7844 | // $ANTLR start "entryRuleBoundedScopeDefinition" |
| 5740 | // InternalSolverLanguage.g:1970:1: entryRuleCDInterpretation returns [EObject current=null] : iv_ruleCDInterpretation= ruleCDInterpretation EOF ; | 7845 | // InternalSolverLanguageParser.g:3032:1: entryRuleBoundedScopeDefinition returns [EObject current=null] : iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ; |
| 5741 | public final EObject entryRuleCDInterpretation() throws RecognitionException { | 7846 | public final EObject entryRuleBoundedScopeDefinition() throws RecognitionException { |
| 5742 | EObject current = null; | 7847 | EObject current = null; |
| 5743 | 7848 | ||
| 5744 | EObject iv_ruleCDInterpretation = null; | 7849 | EObject iv_ruleBoundedScopeDefinition = null; |
| 5745 | 7850 | ||
| 5746 | 7851 | ||
| 5747 | try { | 7852 | try { |
| 5748 | // InternalSolverLanguage.g:1970:57: (iv_ruleCDInterpretation= ruleCDInterpretation EOF ) | 7853 | // InternalSolverLanguageParser.g:3032:63: (iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ) |
| 5749 | // InternalSolverLanguage.g:1971:2: iv_ruleCDInterpretation= ruleCDInterpretation EOF | 7854 | // InternalSolverLanguageParser.g:3033:2: iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF |
| 5750 | { | 7855 | { |
| 5751 | newCompositeNode(grammarAccess.getCDInterpretationRule()); | 7856 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); |
| 5752 | pushFollow(FOLLOW_1); | 7857 | pushFollow(FOLLOW_1); |
| 5753 | iv_ruleCDInterpretation=ruleCDInterpretation(); | 7858 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition(); |
| 5754 | 7859 | ||
| 5755 | state._fsp--; | 7860 | state._fsp--; |
| 5756 | 7861 | ||
| 5757 | current =iv_ruleCDInterpretation; | 7862 | current =iv_ruleBoundedScopeDefinition; |
| 5758 | match(input,EOF,FOLLOW_2); | 7863 | match(input,EOF,FOLLOW_2); |
| 5759 | 7864 | ||
| 5760 | } | 7865 | } |
| @@ -5769,107 +7874,299 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5769 | } | 7874 | } |
| 5770 | return current; | 7875 | return current; |
| 5771 | } | 7876 | } |
| 5772 | // $ANTLR end "entryRuleCDInterpretation" | 7877 | // $ANTLR end "entryRuleBoundedScopeDefinition" |
| 5773 | 7878 | ||
| 5774 | 7879 | ||
| 5775 | // $ANTLR start "ruleCDInterpretation" | 7880 | // $ANTLR start "ruleBoundedScopeDefinition" |
| 5776 | // InternalSolverLanguage.g:1977:1: ruleCDInterpretation returns [EObject current=null] : (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ; | 7881 | // InternalSolverLanguageParser.g:3039:1: ruleBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) ; |
| 5777 | public final EObject ruleCDInterpretation() throws RecognitionException { | 7882 | public final EObject ruleBoundedScopeDefinition() throws RecognitionException { |
| 5778 | EObject current = null; | 7883 | EObject current = null; |
| 5779 | 7884 | ||
| 5780 | EObject this_ClassInterpretation_0 = null; | 7885 | Token otherlv_0=null; |
| 5781 | 7886 | Token lv_lowerBound_1_0=null; | |
| 5782 | EObject this_EnumInterpretation_1 = null; | 7887 | Token otherlv_2=null; |
| 5783 | 7888 | Token otherlv_4=null; | |
| 5784 | EObject this_GlobalRelationInterpretation_2 = null; | 7889 | Token lv_upperBound_5_0=null; |
| 5785 | 7890 | Token lv_upperBound_6_0=null; | |
| 7891 | Token otherlv_7=null; | ||
| 7892 | Token otherlv_9=null; | ||
| 7893 | Token lv_lowerBound_10_0=null; | ||
| 5786 | 7894 | ||
| 5787 | 7895 | ||
| 5788 | enterRule(); | 7896 | enterRule(); |
| 5789 | 7897 | ||
| 5790 | try { | 7898 | try { |
| 5791 | // InternalSolverLanguage.g:1983:2: ( (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ) | 7899 | // InternalSolverLanguageParser.g:3045:2: ( (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) ) |
| 5792 | // InternalSolverLanguage.g:1984:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) | 7900 | // InternalSolverLanguageParser.g:3046:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) |
| 5793 | { | 7901 | { |
| 5794 | // InternalSolverLanguage.g:1984:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) | 7902 | // InternalSolverLanguageParser.g:3046:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) |
| 5795 | int alt36=3; | 7903 | // InternalSolverLanguageParser.g:3047:3: otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) |
| 5796 | switch ( input.LA(1) ) { | 7904 | { |
| 5797 | case 33: | 7905 | otherlv_0=(Token)match(input,Scope,FOLLOW_47); |
| 5798 | case 34: | 7906 | |
| 5799 | { | 7907 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
| 5800 | alt36=1; | 7908 | |
| 7909 | // InternalSolverLanguageParser.g:3051:3: ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) | ||
| 7910 | int alt38=2; | ||
| 7911 | int LA38_0 = input.LA(1); | ||
| 7912 | |||
| 7913 | if ( (LA38_0==RULE_INT) ) { | ||
| 7914 | int LA38_1 = input.LA(2); | ||
| 7915 | |||
| 7916 | if ( (LA38_1==GreaterThanSignEqualsSign) ) { | ||
| 7917 | alt38=2; | ||
| 5801 | } | 7918 | } |
| 5802 | break; | 7919 | else if ( (LA38_1==LessThanSignEqualsSign) ) { |
| 5803 | case 38: | 7920 | alt38=1; |
| 5804 | { | ||
| 5805 | alt36=2; | ||
| 5806 | } | 7921 | } |
| 5807 | break; | 7922 | else { |
| 5808 | case 39: | 7923 | NoViableAltException nvae = |
| 5809 | case 40: | 7924 | new NoViableAltException("", 38, 1, input); |
| 5810 | { | 7925 | |
| 5811 | alt36=3; | 7926 | throw nvae; |
| 5812 | } | 7927 | } |
| 5813 | break; | 7928 | } |
| 5814 | default: | 7929 | else if ( (LA38_0==RULE_QUOTED_ID||LA38_0==RULE_ID) ) { |
| 7930 | alt38=1; | ||
| 7931 | } | ||
| 7932 | else { | ||
| 5815 | NoViableAltException nvae = | 7933 | NoViableAltException nvae = |
| 5816 | new NoViableAltException("", 36, 0, input); | 7934 | new NoViableAltException("", 38, 0, input); |
| 5817 | 7935 | ||
| 5818 | throw nvae; | 7936 | throw nvae; |
| 5819 | } | 7937 | } |
| 5820 | 7938 | switch (alt38) { | |
| 5821 | switch (alt36) { | ||
| 5822 | case 1 : | 7939 | case 1 : |
| 5823 | // InternalSolverLanguage.g:1985:3: this_ClassInterpretation_0= ruleClassInterpretation | 7940 | // InternalSolverLanguageParser.g:3052:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) |
| 5824 | { | 7941 | { |
| 7942 | // InternalSolverLanguageParser.g:3052:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ||
| 7943 | // InternalSolverLanguageParser.g:3053:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) | ||
| 7944 | { | ||
| 7945 | // InternalSolverLanguageParser.g:3053:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? | ||
| 7946 | int alt36=2; | ||
| 7947 | int LA36_0 = input.LA(1); | ||
| 5825 | 7948 | ||
| 5826 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); | 7949 | if ( (LA36_0==RULE_INT) ) { |
| 5827 | 7950 | alt36=1; | |
| 5828 | pushFollow(FOLLOW_2); | 7951 | } |
| 5829 | this_ClassInterpretation_0=ruleClassInterpretation(); | 7952 | switch (alt36) { |
| 7953 | case 1 : | ||
| 7954 | // InternalSolverLanguageParser.g:3054:6: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign | ||
| 7955 | { | ||
| 7956 | // InternalSolverLanguageParser.g:3054:6: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
| 7957 | // InternalSolverLanguageParser.g:3055:7: (lv_lowerBound_1_0= RULE_INT ) | ||
| 7958 | { | ||
| 7959 | // InternalSolverLanguageParser.g:3055:7: (lv_lowerBound_1_0= RULE_INT ) | ||
| 7960 | // InternalSolverLanguageParser.g:3056:8: lv_lowerBound_1_0= RULE_INT | ||
| 7961 | { | ||
| 7962 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_48); | ||
| 7963 | |||
| 7964 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
| 7965 | |||
| 7966 | |||
| 7967 | if (current==null) { | ||
| 7968 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 7969 | } | ||
| 7970 | setWithLastConsumed( | ||
| 7971 | current, | ||
| 7972 | "lowerBound", | ||
| 7973 | lv_lowerBound_1_0, | ||
| 7974 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 7975 | |||
| 7976 | |||
| 7977 | } | ||
| 7978 | |||
| 7979 | |||
| 7980 | } | ||
| 7981 | |||
| 7982 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_8); | ||
| 7983 | |||
| 7984 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
| 7985 | |||
| 7986 | |||
| 7987 | } | ||
| 7988 | break; | ||
| 7989 | |||
| 7990 | } | ||
| 7991 | |||
| 7992 | // InternalSolverLanguageParser.g:3077:5: ( ( ruleQualifiedName ) ) | ||
| 7993 | // InternalSolverLanguageParser.g:3078:6: ( ruleQualifiedName ) | ||
| 7994 | { | ||
| 7995 | // InternalSolverLanguageParser.g:3078:6: ( ruleQualifiedName ) | ||
| 7996 | // InternalSolverLanguageParser.g:3079:7: ruleQualifiedName | ||
| 7997 | { | ||
| 7998 | |||
| 7999 | if (current==null) { | ||
| 8000 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8001 | } | ||
| 8002 | |||
| 8003 | |||
| 8004 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | ||
| 8005 | |||
| 8006 | pushFollow(FOLLOW_48); | ||
| 8007 | ruleQualifiedName(); | ||
| 5830 | 8008 | ||
| 5831 | state._fsp--; | 8009 | state._fsp--; |
| 5832 | 8010 | ||
| 5833 | 8011 | ||
| 5834 | current = this_ClassInterpretation_0; | 8012 | afterParserOrEnumRuleCall(); |
| 5835 | afterParserOrEnumRuleCall(); | 8013 | |
| 5836 | 8014 | ||
| 8015 | } | ||
| 8016 | |||
| 8017 | |||
| 8018 | } | ||
| 8019 | |||
| 8020 | otherlv_4=(Token)match(input,LessThanSignEqualsSign,FOLLOW_45); | ||
| 8021 | |||
| 8022 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
| 8023 | |||
| 8024 | // InternalSolverLanguageParser.g:3097:5: ( (lv_upperBound_5_0= RULE_INT ) ) | ||
| 8025 | // InternalSolverLanguageParser.g:3098:6: (lv_upperBound_5_0= RULE_INT ) | ||
| 8026 | { | ||
| 8027 | // InternalSolverLanguageParser.g:3098:6: (lv_upperBound_5_0= RULE_INT ) | ||
| 8028 | // InternalSolverLanguageParser.g:3099:7: lv_upperBound_5_0= RULE_INT | ||
| 8029 | { | ||
| 8030 | lv_upperBound_5_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
| 8031 | |||
| 8032 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
| 8033 | |||
| 8034 | |||
| 8035 | if (current==null) { | ||
| 8036 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8037 | } | ||
| 8038 | setWithLastConsumed( | ||
| 8039 | current, | ||
| 8040 | "upperBound", | ||
| 8041 | lv_upperBound_5_0, | ||
| 8042 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8043 | |||
| 8044 | |||
| 8045 | } | ||
| 8046 | |||
| 8047 | |||
| 8048 | } | ||
| 8049 | |||
| 8050 | |||
| 8051 | } | ||
| 8052 | |||
| 5837 | 8053 | ||
| 5838 | } | 8054 | } |
| 5839 | break; | 8055 | break; |
| 5840 | case 2 : | 8056 | case 2 : |
| 5841 | // InternalSolverLanguage.g:1994:3: this_EnumInterpretation_1= ruleEnumInterpretation | 8057 | // InternalSolverLanguageParser.g:3117:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) |
| 5842 | { | 8058 | { |
| 8059 | // InternalSolverLanguageParser.g:3117:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | ||
| 8060 | // InternalSolverLanguageParser.g:3118:5: ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
| 8061 | { | ||
| 8062 | // InternalSolverLanguageParser.g:3118:5: ( (lv_upperBound_6_0= RULE_INT ) ) | ||
| 8063 | // InternalSolverLanguageParser.g:3119:6: (lv_upperBound_6_0= RULE_INT ) | ||
| 8064 | { | ||
| 8065 | // InternalSolverLanguageParser.g:3119:6: (lv_upperBound_6_0= RULE_INT ) | ||
| 8066 | // InternalSolverLanguageParser.g:3120:7: lv_upperBound_6_0= RULE_INT | ||
| 8067 | { | ||
| 8068 | lv_upperBound_6_0=(Token)match(input,RULE_INT,FOLLOW_49); | ||
| 5843 | 8069 | ||
| 5844 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); | 8070 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
| 5845 | 8071 | ||
| 5846 | pushFollow(FOLLOW_2); | ||
| 5847 | this_EnumInterpretation_1=ruleEnumInterpretation(); | ||
| 5848 | 8072 | ||
| 5849 | state._fsp--; | 8073 | if (current==null) { |
| 8074 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8075 | } | ||
| 8076 | setWithLastConsumed( | ||
| 8077 | current, | ||
| 8078 | "upperBound", | ||
| 8079 | lv_upperBound_6_0, | ||
| 8080 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8081 | |||
| 5850 | 8082 | ||
| 8083 | } | ||
| 5851 | 8084 | ||
| 5852 | current = this_EnumInterpretation_1; | ||
| 5853 | afterParserOrEnumRuleCall(); | ||
| 5854 | |||
| 5855 | 8085 | ||
| 5856 | } | 8086 | } |
| 5857 | break; | 8087 | |
| 5858 | case 3 : | 8088 | otherlv_7=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_8); |
| 5859 | // InternalSolverLanguage.g:2003:3: this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation | 8089 | |
| 8090 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 8091 | |||
| 8092 | // InternalSolverLanguageParser.g:3140:5: ( ( ruleQualifiedName ) ) | ||
| 8093 | // InternalSolverLanguageParser.g:3141:6: ( ruleQualifiedName ) | ||
| 8094 | { | ||
| 8095 | // InternalSolverLanguageParser.g:3141:6: ( ruleQualifiedName ) | ||
| 8096 | // InternalSolverLanguageParser.g:3142:7: ruleQualifiedName | ||
| 5860 | { | 8097 | { |
| 5861 | 8098 | ||
| 5862 | newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); | 8099 | if (current==null) { |
| 5863 | 8100 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | |
| 5864 | pushFollow(FOLLOW_2); | 8101 | } |
| 5865 | this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation(); | 8102 | |
| 8103 | |||
| 8104 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
| 8105 | |||
| 8106 | pushFollow(FOLLOW_50); | ||
| 8107 | ruleQualifiedName(); | ||
| 5866 | 8108 | ||
| 5867 | state._fsp--; | 8109 | state._fsp--; |
| 5868 | 8110 | ||
| 5869 | 8111 | ||
| 5870 | current = this_GlobalRelationInterpretation_2; | 8112 | afterParserOrEnumRuleCall(); |
| 5871 | afterParserOrEnumRuleCall(); | 8113 | |
| 5872 | 8114 | ||
| 8115 | } | ||
| 8116 | |||
| 8117 | |||
| 8118 | } | ||
| 8119 | |||
| 8120 | // InternalSolverLanguageParser.g:3156:5: (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
| 8121 | int alt37=2; | ||
| 8122 | int LA37_0 = input.LA(1); | ||
| 8123 | |||
| 8124 | if ( (LA37_0==GreaterThanSignEqualsSign) ) { | ||
| 8125 | alt37=1; | ||
| 8126 | } | ||
| 8127 | switch (alt37) { | ||
| 8128 | case 1 : | ||
| 8129 | // InternalSolverLanguageParser.g:3157:6: otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
| 8130 | { | ||
| 8131 | otherlv_9=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_45); | ||
| 8132 | |||
| 8133 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
| 8134 | |||
| 8135 | // InternalSolverLanguageParser.g:3161:6: ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
| 8136 | // InternalSolverLanguageParser.g:3162:7: (lv_lowerBound_10_0= RULE_INT ) | ||
| 8137 | { | ||
| 8138 | // InternalSolverLanguageParser.g:3162:7: (lv_lowerBound_10_0= RULE_INT ) | ||
| 8139 | // InternalSolverLanguageParser.g:3163:8: lv_lowerBound_10_0= RULE_INT | ||
| 8140 | { | ||
| 8141 | lv_lowerBound_10_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
| 8142 | |||
| 8143 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
| 8144 | |||
| 8145 | |||
| 8146 | if (current==null) { | ||
| 8147 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | ||
| 8148 | } | ||
| 8149 | setWithLastConsumed( | ||
| 8150 | current, | ||
| 8151 | "lowerBound", | ||
| 8152 | lv_lowerBound_10_0, | ||
| 8153 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8154 | |||
| 8155 | |||
| 8156 | } | ||
| 8157 | |||
| 8158 | |||
| 8159 | } | ||
| 8160 | |||
| 8161 | |||
| 8162 | } | ||
| 8163 | break; | ||
| 8164 | |||
| 8165 | } | ||
| 8166 | |||
| 8167 | |||
| 8168 | } | ||
| 8169 | |||
| 5873 | 8170 | ||
| 5874 | } | 8171 | } |
| 5875 | break; | 8172 | break; |
| @@ -5880,6 +8177,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5880 | } | 8177 | } |
| 5881 | 8178 | ||
| 5882 | 8179 | ||
| 8180 | } | ||
| 8181 | |||
| 8182 | |||
| 5883 | leaveRule(); | 8183 | leaveRule(); |
| 5884 | 8184 | ||
| 5885 | } | 8185 | } |
| @@ -5892,28 +8192,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5892 | } | 8192 | } |
| 5893 | return current; | 8193 | return current; |
| 5894 | } | 8194 | } |
| 5895 | // $ANTLR end "ruleCDInterpretation" | 8195 | // $ANTLR end "ruleBoundedScopeDefinition" |
| 5896 | 8196 | ||
| 5897 | 8197 | ||
| 5898 | // $ANTLR start "entryRuleClassInterpretation" | 8198 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" |
| 5899 | // InternalSolverLanguage.g:2015:1: entryRuleClassInterpretation returns [EObject current=null] : iv_ruleClassInterpretation= ruleClassInterpretation EOF ; | 8199 | // InternalSolverLanguageParser.g:3186:1: entryRuleLowerBoundedScopeDefinition returns [EObject current=null] : iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ; |
| 5900 | public final EObject entryRuleClassInterpretation() throws RecognitionException { | 8200 | public final EObject entryRuleLowerBoundedScopeDefinition() throws RecognitionException { |
| 5901 | EObject current = null; | 8201 | EObject current = null; |
| 5902 | 8202 | ||
| 5903 | EObject iv_ruleClassInterpretation = null; | 8203 | EObject iv_ruleLowerBoundedScopeDefinition = null; |
| 5904 | 8204 | ||
| 5905 | 8205 | ||
| 5906 | try { | 8206 | try { |
| 5907 | // InternalSolverLanguage.g:2015:60: (iv_ruleClassInterpretation= ruleClassInterpretation EOF ) | 8207 | // InternalSolverLanguageParser.g:3186:68: (iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ) |
| 5908 | // InternalSolverLanguage.g:2016:2: iv_ruleClassInterpretation= ruleClassInterpretation EOF | 8208 | // InternalSolverLanguageParser.g:3187:2: iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF |
| 5909 | { | 8209 | { |
| 5910 | newCompositeNode(grammarAccess.getClassInterpretationRule()); | 8210 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 5911 | pushFollow(FOLLOW_1); | 8211 | pushFollow(FOLLOW_1); |
| 5912 | iv_ruleClassInterpretation=ruleClassInterpretation(); | 8212 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition(); |
| 5913 | 8213 | ||
| 5914 | state._fsp--; | 8214 | state._fsp--; |
| 5915 | 8215 | ||
| 5916 | current =iv_ruleClassInterpretation; | 8216 | current =iv_ruleLowerBoundedScopeDefinition; |
| 5917 | match(input,EOF,FOLLOW_2); | 8217 | match(input,EOF,FOLLOW_2); |
| 5918 | 8218 | ||
| 5919 | } | 8219 | } |
| @@ -5928,236 +8228,194 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 5928 | } | 8228 | } |
| 5929 | return current; | 8229 | return current; |
| 5930 | } | 8230 | } |
| 5931 | // $ANTLR end "entryRuleClassInterpretation" | 8231 | // $ANTLR end "entryRuleLowerBoundedScopeDefinition" |
| 5932 | 8232 | ||
| 5933 | 8233 | ||
| 5934 | // $ANTLR start "ruleClassInterpretation" | 8234 | // $ANTLR start "ruleLowerBoundedScopeDefinition" |
| 5935 | // InternalSolverLanguage.g:2022:1: ruleClassInterpretation returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ; | 8235 | // InternalSolverLanguageParser.g:3193:1: ruleLowerBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) ; |
| 5936 | public final EObject ruleClassInterpretation() throws RecognitionException { | 8236 | public final EObject ruleLowerBoundedScopeDefinition() throws RecognitionException { |
| 5937 | EObject current = null; | 8237 | EObject current = null; |
| 5938 | 8238 | ||
| 5939 | Token lv_abstract_0_0=null; | 8239 | Token otherlv_0=null; |
| 5940 | Token otherlv_1=null; | 8240 | Token lv_lowerBound_1_0=null; |
| 5941 | Token otherlv_3=null; | 8241 | Token otherlv_2=null; |
| 5942 | Token otherlv_5=null; | 8242 | Token otherlv_5=null; |
| 5943 | Token otherlv_7=null; | 8243 | Token lv_lowerBound_6_0=null; |
| 5944 | EObject lv_symbol_2_0 = null; | ||
| 5945 | |||
| 5946 | EObject lv_supertypes_4_0 = null; | ||
| 5947 | |||
| 5948 | EObject lv_fielt_6_0 = null; | ||
| 5949 | |||
| 5950 | 8244 | ||
| 5951 | 8245 | ||
| 5952 | enterRule(); | 8246 | enterRule(); |
| 5953 | 8247 | ||
| 5954 | try { | 8248 | try { |
| 5955 | // InternalSolverLanguage.g:2028:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ) | 8249 | // InternalSolverLanguageParser.g:3199:2: ( (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) ) |
| 5956 | // InternalSolverLanguage.g:2029:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) | 8250 | // InternalSolverLanguageParser.g:3200:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) |
| 5957 | { | 8251 | { |
| 5958 | // InternalSolverLanguage.g:2029:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) | 8252 | // InternalSolverLanguageParser.g:3200:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) |
| 5959 | // InternalSolverLanguage.g:2030:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' | 8253 | // InternalSolverLanguageParser.g:3201:3: otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) |
| 5960 | { | 8254 | { |
| 5961 | // InternalSolverLanguage.g:2030:3: ( (lv_abstract_0_0= 'abstract' ) )? | 8255 | otherlv_0=(Token)match(input,Scope,FOLLOW_47); |
| 5962 | int alt37=2; | 8256 | |
| 5963 | int LA37_0 = input.LA(1); | 8257 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
| 8258 | |||
| 8259 | // InternalSolverLanguageParser.g:3205:3: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) | ||
| 8260 | int alt39=2; | ||
| 8261 | int LA39_0 = input.LA(1); | ||
| 5964 | 8262 | ||
| 5965 | if ( (LA37_0==33) ) { | 8263 | if ( (LA39_0==RULE_INT) ) { |
| 5966 | alt37=1; | 8264 | alt39=1; |
| 8265 | } | ||
| 8266 | else if ( (LA39_0==RULE_QUOTED_ID||LA39_0==RULE_ID) ) { | ||
| 8267 | alt39=2; | ||
| 5967 | } | 8268 | } |
| 5968 | switch (alt37) { | 8269 | else { |
| 8270 | NoViableAltException nvae = | ||
| 8271 | new NoViableAltException("", 39, 0, input); | ||
| 8272 | |||
| 8273 | throw nvae; | ||
| 8274 | } | ||
| 8275 | switch (alt39) { | ||
| 5969 | case 1 : | 8276 | case 1 : |
| 5970 | // InternalSolverLanguage.g:2031:4: (lv_abstract_0_0= 'abstract' ) | 8277 | // InternalSolverLanguageParser.g:3206:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) |
| 8278 | { | ||
| 8279 | // InternalSolverLanguageParser.g:3206:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ||
| 8280 | // InternalSolverLanguageParser.g:3207:5: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) | ||
| 8281 | { | ||
| 8282 | // InternalSolverLanguageParser.g:3207:5: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
| 8283 | // InternalSolverLanguageParser.g:3208:6: (lv_lowerBound_1_0= RULE_INT ) | ||
| 5971 | { | 8284 | { |
| 5972 | // InternalSolverLanguage.g:2031:4: (lv_abstract_0_0= 'abstract' ) | 8285 | // InternalSolverLanguageParser.g:3208:6: (lv_lowerBound_1_0= RULE_INT ) |
| 5973 | // InternalSolverLanguage.g:2032:5: lv_abstract_0_0= 'abstract' | 8286 | // InternalSolverLanguageParser.g:3209:7: lv_lowerBound_1_0= RULE_INT |
| 5974 | { | 8287 | { |
| 5975 | lv_abstract_0_0=(Token)match(input,33,FOLLOW_27); | 8288 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_48); |
| 5976 | 8289 | ||
| 5977 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); | 8290 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); |
| 5978 | 8291 | ||
| 5979 | 8292 | ||
| 5980 | if (current==null) { | 8293 | if (current==null) { |
| 5981 | current = createModelElement(grammarAccess.getClassInterpretationRule()); | 8294 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
| 5982 | } | 8295 | } |
| 5983 | setWithLastConsumed(current, "abstract", true, "abstract"); | 8296 | setWithLastConsumed( |
| 5984 | 8297 | current, | |
| 8298 | "lowerBound", | ||
| 8299 | lv_lowerBound_1_0, | ||
| 8300 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8301 | |||
| 5985 | 8302 | ||
| 5986 | } | 8303 | } |
| 5987 | 8304 | ||
| 5988 | 8305 | ||
| 5989 | } | 8306 | } |
| 5990 | break; | ||
| 5991 | |||
| 5992 | } | ||
| 5993 | |||
| 5994 | otherlv_1=(Token)match(input,34,FOLLOW_12); | ||
| 5995 | |||
| 5996 | newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); | ||
| 5997 | |||
| 5998 | // InternalSolverLanguage.g:2048:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) | ||
| 5999 | // InternalSolverLanguage.g:2049:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6000 | { | ||
| 6001 | // InternalSolverLanguage.g:2049:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6002 | // InternalSolverLanguage.g:2050:5: lv_symbol_2_0= ruleModelSymbol | ||
| 6003 | { | ||
| 6004 | |||
| 6005 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | ||
| 6006 | |||
| 6007 | pushFollow(FOLLOW_28); | ||
| 6008 | lv_symbol_2_0=ruleModelSymbol(); | ||
| 6009 | 8307 | ||
| 6010 | state._fsp--; | 8308 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_8); |
| 6011 | |||
| 6012 | |||
| 6013 | if (current==null) { | ||
| 6014 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 6015 | } | ||
| 6016 | set( | ||
| 6017 | current, | ||
| 6018 | "symbol", | ||
| 6019 | lv_symbol_2_0, | ||
| 6020 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6021 | afterParserOrEnumRuleCall(); | ||
| 6022 | |||
| 6023 | 8309 | ||
| 6024 | } | 8310 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
| 8311 | |||
| 8312 | // InternalSolverLanguageParser.g:3229:5: ( ( ruleQualifiedName ) ) | ||
| 8313 | // InternalSolverLanguageParser.g:3230:6: ( ruleQualifiedName ) | ||
| 8314 | { | ||
| 8315 | // InternalSolverLanguageParser.g:3230:6: ( ruleQualifiedName ) | ||
| 8316 | // InternalSolverLanguageParser.g:3231:7: ruleQualifiedName | ||
| 8317 | { | ||
| 6025 | 8318 | ||
| 8319 | if (current==null) { | ||
| 8320 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 8321 | } | ||
| 8322 | |||
| 6026 | 8323 | ||
| 6027 | } | 8324 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); |
| 8325 | |||
| 8326 | pushFollow(FOLLOW_2); | ||
| 8327 | ruleQualifiedName(); | ||
| 6028 | 8328 | ||
| 6029 | // InternalSolverLanguage.g:2067:3: (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? | 8329 | state._fsp--; |
| 6030 | int alt39=2; | ||
| 6031 | int LA39_0 = input.LA(1); | ||
| 6032 | 8330 | ||
| 6033 | if ( (LA39_0==35) ) { | ||
| 6034 | alt39=1; | ||
| 6035 | } | ||
| 6036 | switch (alt39) { | ||
| 6037 | case 1 : | ||
| 6038 | // InternalSolverLanguage.g:2068:4: otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ | ||
| 6039 | { | ||
| 6040 | otherlv_3=(Token)match(input,35,FOLLOW_12); | ||
| 6041 | 8331 | ||
| 6042 | newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); | 8332 | afterParserOrEnumRuleCall(); |
| 6043 | 8333 | ||
| 6044 | // InternalSolverLanguage.g:2072:4: ( (lv_supertypes_4_0= ruleModelSymbol ) )+ | ||
| 6045 | int cnt38=0; | ||
| 6046 | loop38: | ||
| 6047 | do { | ||
| 6048 | int alt38=2; | ||
| 6049 | int LA38_0 = input.LA(1); | ||
| 6050 | 8334 | ||
| 6051 | if ( (LA38_0==RULE_ID) ) { | 8335 | } |
| 6052 | alt38=1; | ||
| 6053 | } | ||
| 6054 | 8336 | ||
| 6055 | 8337 | ||
| 6056 | switch (alt38) { | 8338 | } |
| 6057 | case 1 : | ||
| 6058 | // InternalSolverLanguage.g:2073:5: (lv_supertypes_4_0= ruleModelSymbol ) | ||
| 6059 | { | ||
| 6060 | // InternalSolverLanguage.g:2073:5: (lv_supertypes_4_0= ruleModelSymbol ) | ||
| 6061 | // InternalSolverLanguage.g:2074:6: lv_supertypes_4_0= ruleModelSymbol | ||
| 6062 | { | ||
| 6063 | 8339 | ||
| 6064 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); | ||
| 6065 | |||
| 6066 | pushFollow(FOLLOW_29); | ||
| 6067 | lv_supertypes_4_0=ruleModelSymbol(); | ||
| 6068 | 8340 | ||
| 6069 | state._fsp--; | 8341 | } |
| 6070 | 8342 | ||
| 6071 | 8343 | ||
| 6072 | if (current==null) { | 8344 | } |
| 6073 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | 8345 | break; |
| 6074 | } | 8346 | case 2 : |
| 6075 | add( | 8347 | // InternalSolverLanguageParser.g:3247:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) |
| 6076 | current, | 8348 | { |
| 6077 | "supertypes", | 8349 | // InternalSolverLanguageParser.g:3247:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) |
| 6078 | lv_supertypes_4_0, | 8350 | // InternalSolverLanguageParser.g:3248:5: ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) |
| 6079 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 8351 | { |
| 6080 | afterParserOrEnumRuleCall(); | 8352 | // InternalSolverLanguageParser.g:3248:5: ( ( ruleQualifiedName ) ) |
| 6081 | 8353 | // InternalSolverLanguageParser.g:3249:6: ( ruleQualifiedName ) | |
| 8354 | { | ||
| 8355 | // InternalSolverLanguageParser.g:3249:6: ( ruleQualifiedName ) | ||
| 8356 | // InternalSolverLanguageParser.g:3250:7: ruleQualifiedName | ||
| 8357 | { | ||
| 6082 | 8358 | ||
| 6083 | } | 8359 | if (current==null) { |
| 8360 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
| 8361 | } | ||
| 8362 | |||
| 6084 | 8363 | ||
| 8364 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | ||
| 8365 | |||
| 8366 | pushFollow(FOLLOW_49); | ||
| 8367 | ruleQualifiedName(); | ||
| 6085 | 8368 | ||
| 6086 | } | 8369 | state._fsp--; |
| 6087 | break; | ||
| 6088 | 8370 | ||
| 6089 | default : | ||
| 6090 | if ( cnt38 >= 1 ) break loop38; | ||
| 6091 | EarlyExitException eee = | ||
| 6092 | new EarlyExitException(38, input); | ||
| 6093 | throw eee; | ||
| 6094 | } | ||
| 6095 | cnt38++; | ||
| 6096 | } while (true); | ||
| 6097 | 8371 | ||
| 8372 | afterParserOrEnumRuleCall(); | ||
| 8373 | |||
| 6098 | 8374 | ||
| 6099 | } | 8375 | } |
| 6100 | break; | ||
| 6101 | 8376 | ||
| 6102 | } | ||
| 6103 | |||
| 6104 | otherlv_5=(Token)match(input,36,FOLLOW_30); | ||
| 6105 | 8377 | ||
| 6106 | newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); | 8378 | } |
| 6107 | |||
| 6108 | // InternalSolverLanguage.g:2096:3: ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* | ||
| 6109 | loop40: | ||
| 6110 | do { | ||
| 6111 | int alt40=2; | ||
| 6112 | int LA40_0 = input.LA(1); | ||
| 6113 | 8379 | ||
| 6114 | if ( (LA40_0==RULE_ID||LA40_0==39) ) { | 8380 | otherlv_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_45); |
| 6115 | alt40=1; | ||
| 6116 | } | ||
| 6117 | 8381 | ||
| 8382 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
| 8383 | |||
| 8384 | // InternalSolverLanguageParser.g:3268:5: ( (lv_lowerBound_6_0= RULE_INT ) ) | ||
| 8385 | // InternalSolverLanguageParser.g:3269:6: (lv_lowerBound_6_0= RULE_INT ) | ||
| 8386 | { | ||
| 8387 | // InternalSolverLanguageParser.g:3269:6: (lv_lowerBound_6_0= RULE_INT ) | ||
| 8388 | // InternalSolverLanguageParser.g:3270:7: lv_lowerBound_6_0= RULE_INT | ||
| 8389 | { | ||
| 8390 | lv_lowerBound_6_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
| 6118 | 8391 | ||
| 6119 | switch (alt40) { | 8392 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
| 6120 | case 1 : | 8393 | |
| 6121 | // InternalSolverLanguage.g:2097:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) | ||
| 6122 | { | ||
| 6123 | // InternalSolverLanguage.g:2097:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) | ||
| 6124 | // InternalSolverLanguage.g:2098:5: lv_fielt_6_0= ruleFieldRelationInterpretation | ||
| 6125 | { | ||
| 6126 | 8394 | ||
| 6127 | newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); | 8395 | if (current==null) { |
| 6128 | 8396 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | |
| 6129 | pushFollow(FOLLOW_30); | 8397 | } |
| 6130 | lv_fielt_6_0=ruleFieldRelationInterpretation(); | 8398 | setWithLastConsumed( |
| 8399 | current, | ||
| 8400 | "lowerBound", | ||
| 8401 | lv_lowerBound_6_0, | ||
| 8402 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 8403 | |||
| 6131 | 8404 | ||
| 6132 | state._fsp--; | 8405 | } |
| 6133 | 8406 | ||
| 6134 | 8407 | ||
| 6135 | if (current==null) { | 8408 | } |
| 6136 | current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); | ||
| 6137 | } | ||
| 6138 | add( | ||
| 6139 | current, | ||
| 6140 | "fielt", | ||
| 6141 | lv_fielt_6_0, | ||
| 6142 | "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | ||
| 6143 | afterParserOrEnumRuleCall(); | ||
| 6144 | |||
| 6145 | 8409 | ||
| 6146 | } | ||
| 6147 | 8410 | ||
| 8411 | } | ||
| 6148 | 8412 | ||
| 6149 | } | ||
| 6150 | break; | ||
| 6151 | 8413 | ||
| 6152 | default : | 8414 | } |
| 6153 | break loop40; | 8415 | break; |
| 6154 | } | ||
| 6155 | } while (true); | ||
| 6156 | 8416 | ||
| 6157 | otherlv_7=(Token)match(input,37,FOLLOW_2); | 8417 | } |
| 6158 | 8418 | ||
| 6159 | newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); | ||
| 6160 | |||
| 6161 | 8419 | ||
| 6162 | } | 8420 | } |
| 6163 | 8421 | ||
| @@ -6177,28 +8435,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6177 | } | 8435 | } |
| 6178 | return current; | 8436 | return current; |
| 6179 | } | 8437 | } |
| 6180 | // $ANTLR end "ruleClassInterpretation" | 8438 | // $ANTLR end "ruleLowerBoundedScopeDefinition" |
| 6181 | 8439 | ||
| 6182 | 8440 | ||
| 6183 | // $ANTLR start "entryRuleEnumInterpretation" | 8441 | // $ANTLR start "entryRuleObjectiveDefinition" |
| 6184 | // InternalSolverLanguage.g:2123:1: entryRuleEnumInterpretation returns [EObject current=null] : iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ; | 8442 | // InternalSolverLanguageParser.g:3292:1: entryRuleObjectiveDefinition returns [EObject current=null] : iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ; |
| 6185 | public final EObject entryRuleEnumInterpretation() throws RecognitionException { | 8443 | public final EObject entryRuleObjectiveDefinition() throws RecognitionException { |
| 6186 | EObject current = null; | 8444 | EObject current = null; |
| 6187 | 8445 | ||
| 6188 | EObject iv_ruleEnumInterpretation = null; | 8446 | EObject iv_ruleObjectiveDefinition = null; |
| 6189 | 8447 | ||
| 6190 | 8448 | ||
| 6191 | try { | 8449 | try { |
| 6192 | // InternalSolverLanguage.g:2123:59: (iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ) | 8450 | // InternalSolverLanguageParser.g:3292:60: (iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ) |
| 6193 | // InternalSolverLanguage.g:2124:2: iv_ruleEnumInterpretation= ruleEnumInterpretation EOF | 8451 | // InternalSolverLanguageParser.g:3293:2: iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF |
| 6194 | { | 8452 | { |
| 6195 | newCompositeNode(grammarAccess.getEnumInterpretationRule()); | 8453 | newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); |
| 6196 | pushFollow(FOLLOW_1); | 8454 | pushFollow(FOLLOW_1); |
| 6197 | iv_ruleEnumInterpretation=ruleEnumInterpretation(); | 8455 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition(); |
| 6198 | 8456 | ||
| 6199 | state._fsp--; | 8457 | state._fsp--; |
| 6200 | 8458 | ||
| 6201 | current =iv_ruleEnumInterpretation; | 8459 | current =iv_ruleObjectiveDefinition; |
| 6202 | match(input,EOF,FOLLOW_2); | 8460 | match(input,EOF,FOLLOW_2); |
| 6203 | 8461 | ||
| 6204 | } | 8462 | } |
| @@ -6213,59 +8471,52 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6213 | } | 8471 | } |
| 6214 | return current; | 8472 | return current; |
| 6215 | } | 8473 | } |
| 6216 | // $ANTLR end "entryRuleEnumInterpretation" | 8474 | // $ANTLR end "entryRuleObjectiveDefinition" |
| 6217 | 8475 | ||
| 6218 | 8476 | ||
| 6219 | // $ANTLR start "ruleEnumInterpretation" | 8477 | // $ANTLR start "ruleObjectiveDefinition" |
| 6220 | // InternalSolverLanguage.g:2130:1: ruleEnumInterpretation returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ; | 8478 | // InternalSolverLanguageParser.g:3299:1: ruleObjectiveDefinition returns [EObject current=null] : ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ; |
| 6221 | public final EObject ruleEnumInterpretation() throws RecognitionException { | 8479 | public final EObject ruleObjectiveDefinition() throws RecognitionException { |
| 6222 | EObject current = null; | 8480 | EObject current = null; |
| 6223 | 8481 | ||
| 6224 | Token otherlv_0=null; | 8482 | Enumerator lv_kind_0_0 = null; |
| 6225 | Token otherlv_2=null; | ||
| 6226 | Token otherlv_4=null; | ||
| 6227 | EObject lv_Symbol_1_0 = null; | ||
| 6228 | 8483 | ||
| 6229 | EObject lv_objects_3_0 = null; | 8484 | EObject lv_objective_1_0 = null; |
| 6230 | 8485 | ||
| 6231 | 8486 | ||
| 6232 | 8487 | ||
| 6233 | enterRule(); | 8488 | enterRule(); |
| 6234 | 8489 | ||
| 6235 | try { | 8490 | try { |
| 6236 | // InternalSolverLanguage.g:2136:2: ( (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ) | 8491 | // InternalSolverLanguageParser.g:3305:2: ( ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ) |
| 6237 | // InternalSolverLanguage.g:2137:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) | 8492 | // InternalSolverLanguageParser.g:3306:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
| 6238 | { | 8493 | { |
| 6239 | // InternalSolverLanguage.g:2137:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) | 8494 | // InternalSolverLanguageParser.g:3306:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
| 6240 | // InternalSolverLanguage.g:2138:3: otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' | 8495 | // InternalSolverLanguageParser.g:3307:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) |
| 6241 | { | 8496 | { |
| 6242 | otherlv_0=(Token)match(input,38,FOLLOW_12); | 8497 | // InternalSolverLanguageParser.g:3307:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) |
| 6243 | 8498 | // InternalSolverLanguageParser.g:3308:4: (lv_kind_0_0= ruleObjectiveKind ) | |
| 6244 | newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); | ||
| 6245 | |||
| 6246 | // InternalSolverLanguage.g:2142:3: ( (lv_Symbol_1_0= ruleModelSymbol ) ) | ||
| 6247 | // InternalSolverLanguage.g:2143:4: (lv_Symbol_1_0= ruleModelSymbol ) | ||
| 6248 | { | 8499 | { |
| 6249 | // InternalSolverLanguage.g:2143:4: (lv_Symbol_1_0= ruleModelSymbol ) | 8500 | // InternalSolverLanguageParser.g:3308:4: (lv_kind_0_0= ruleObjectiveKind ) |
| 6250 | // InternalSolverLanguage.g:2144:5: lv_Symbol_1_0= ruleModelSymbol | 8501 | // InternalSolverLanguageParser.g:3309:5: lv_kind_0_0= ruleObjectiveKind |
| 6251 | { | 8502 | { |
| 6252 | 8503 | ||
| 6253 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 8504 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
| 6254 | 8505 | ||
| 6255 | pushFollow(FOLLOW_31); | 8506 | pushFollow(FOLLOW_6); |
| 6256 | lv_Symbol_1_0=ruleModelSymbol(); | 8507 | lv_kind_0_0=ruleObjectiveKind(); |
| 6257 | 8508 | ||
| 6258 | state._fsp--; | 8509 | state._fsp--; |
| 6259 | 8510 | ||
| 6260 | 8511 | ||
| 6261 | if (current==null) { | 8512 | if (current==null) { |
| 6262 | current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | 8513 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); |
| 6263 | } | 8514 | } |
| 6264 | set( | 8515 | set( |
| 6265 | current, | 8516 | current, |
| 6266 | "Symbol", | 8517 | "kind", |
| 6267 | lv_Symbol_1_0, | 8518 | lv_kind_0_0, |
| 6268 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 8519 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); |
| 6269 | afterParserOrEnumRuleCall(); | 8520 | afterParserOrEnumRuleCall(); |
| 6270 | 8521 | ||
| 6271 | 8522 | ||
| @@ -6274,68 +8525,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6274 | 8525 | ||
| 6275 | } | 8526 | } |
| 6276 | 8527 | ||
| 6277 | otherlv_2=(Token)match(input,36,FOLLOW_13); | 8528 | // InternalSolverLanguageParser.g:3326:3: ( (lv_objective_1_0= ruleExpression ) ) |
| 6278 | 8529 | // InternalSolverLanguageParser.g:3327:4: (lv_objective_1_0= ruleExpression ) | |
| 6279 | newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); | 8530 | { |
| 6280 | 8531 | // InternalSolverLanguageParser.g:3327:4: (lv_objective_1_0= ruleExpression ) | |
| 6281 | // InternalSolverLanguage.g:2165:3: ( (lv_objects_3_0= ruleNamedObject ) )+ | 8532 | // InternalSolverLanguageParser.g:3328:5: lv_objective_1_0= ruleExpression |
| 6282 | int cnt41=0; | 8533 | { |
| 6283 | loop41: | ||
| 6284 | do { | ||
| 6285 | int alt41=2; | ||
| 6286 | int LA41_0 = input.LA(1); | ||
| 6287 | |||
| 6288 | if ( (LA41_0==27) ) { | ||
| 6289 | alt41=1; | ||
| 6290 | } | ||
| 6291 | |||
| 6292 | |||
| 6293 | switch (alt41) { | ||
| 6294 | case 1 : | ||
| 6295 | // InternalSolverLanguage.g:2166:4: (lv_objects_3_0= ruleNamedObject ) | ||
| 6296 | { | ||
| 6297 | // InternalSolverLanguage.g:2166:4: (lv_objects_3_0= ruleNamedObject ) | ||
| 6298 | // InternalSolverLanguage.g:2167:5: lv_objects_3_0= ruleNamedObject | ||
| 6299 | { | ||
| 6300 | |||
| 6301 | newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); | ||
| 6302 | |||
| 6303 | pushFollow(FOLLOW_32); | ||
| 6304 | lv_objects_3_0=ruleNamedObject(); | ||
| 6305 | |||
| 6306 | state._fsp--; | ||
| 6307 | 8534 | ||
| 8535 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
| 8536 | |||
| 8537 | pushFollow(FOLLOW_2); | ||
| 8538 | lv_objective_1_0=ruleExpression(); | ||
| 6308 | 8539 | ||
| 6309 | if (current==null) { | 8540 | state._fsp--; |
| 6310 | current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); | ||
| 6311 | } | ||
| 6312 | add( | ||
| 6313 | current, | ||
| 6314 | "objects", | ||
| 6315 | lv_objects_3_0, | ||
| 6316 | "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | ||
| 6317 | afterParserOrEnumRuleCall(); | ||
| 6318 | |||
| 6319 | 8541 | ||
| 6320 | } | ||
| 6321 | 8542 | ||
| 8543 | if (current==null) { | ||
| 8544 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | ||
| 8545 | } | ||
| 8546 | set( | ||
| 8547 | current, | ||
| 8548 | "objective", | ||
| 8549 | lv_objective_1_0, | ||
| 8550 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 8551 | afterParserOrEnumRuleCall(); | ||
| 8552 | |||
| 6322 | 8553 | ||
| 6323 | } | 8554 | } |
| 6324 | break; | ||
| 6325 | 8555 | ||
| 6326 | default : | ||
| 6327 | if ( cnt41 >= 1 ) break loop41; | ||
| 6328 | EarlyExitException eee = | ||
| 6329 | new EarlyExitException(41, input); | ||
| 6330 | throw eee; | ||
| 6331 | } | ||
| 6332 | cnt41++; | ||
| 6333 | } while (true); | ||
| 6334 | 8556 | ||
| 6335 | otherlv_4=(Token)match(input,37,FOLLOW_2); | 8557 | } |
| 6336 | 8558 | ||
| 6337 | newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); | ||
| 6338 | |||
| 6339 | 8559 | ||
| 6340 | } | 8560 | } |
| 6341 | 8561 | ||
| @@ -6355,28 +8575,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6355 | } | 8575 | } |
| 6356 | return current; | 8576 | return current; |
| 6357 | } | 8577 | } |
| 6358 | // $ANTLR end "ruleEnumInterpretation" | 8578 | // $ANTLR end "ruleObjectiveDefinition" |
| 6359 | 8579 | ||
| 6360 | 8580 | ||
| 6361 | // $ANTLR start "entryRuleFieldRelationInterpretation" | 8581 | // $ANTLR start "entryRuleUpperMultiplicty" |
| 6362 | // InternalSolverLanguage.g:2192:1: entryRuleFieldRelationInterpretation returns [EObject current=null] : iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ; | 8582 | // InternalSolverLanguageParser.g:3349:1: entryRuleUpperMultiplicty returns [String current=null] : iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ; |
| 6363 | public final EObject entryRuleFieldRelationInterpretation() throws RecognitionException { | 8583 | public final String entryRuleUpperMultiplicty() throws RecognitionException { |
| 6364 | EObject current = null; | 8584 | String current = null; |
| 6365 | 8585 | ||
| 6366 | EObject iv_ruleFieldRelationInterpretation = null; | 8586 | AntlrDatatypeRuleToken iv_ruleUpperMultiplicty = null; |
| 6367 | 8587 | ||
| 6368 | 8588 | ||
| 6369 | try { | 8589 | try { |
| 6370 | // InternalSolverLanguage.g:2192:68: (iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ) | 8590 | // InternalSolverLanguageParser.g:3349:56: (iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ) |
| 6371 | // InternalSolverLanguage.g:2193:2: iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF | 8591 | // InternalSolverLanguageParser.g:3350:2: iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF |
| 6372 | { | 8592 | { |
| 6373 | newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); | 8593 | newCompositeNode(grammarAccess.getUpperMultiplictyRule()); |
| 6374 | pushFollow(FOLLOW_1); | 8594 | pushFollow(FOLLOW_1); |
| 6375 | iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation(); | 8595 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty(); |
| 6376 | 8596 | ||
| 6377 | state._fsp--; | 8597 | state._fsp--; |
| 6378 | 8598 | ||
| 6379 | current =iv_ruleFieldRelationInterpretation; | 8599 | current =iv_ruleUpperMultiplicty.getText(); |
| 6380 | match(input,EOF,FOLLOW_2); | 8600 | match(input,EOF,FOLLOW_2); |
| 6381 | 8601 | ||
| 6382 | } | 8602 | } |
| @@ -6391,171 +8611,182 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6391 | } | 8611 | } |
| 6392 | return current; | 8612 | return current; |
| 6393 | } | 8613 | } |
| 6394 | // $ANTLR end "entryRuleFieldRelationInterpretation" | 8614 | // $ANTLR end "entryRuleUpperMultiplicty" |
| 6395 | |||
| 6396 | |||
| 6397 | // $ANTLR start "ruleFieldRelationInterpretation" | ||
| 6398 | // InternalSolverLanguage.g:2199:1: ruleFieldRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ; | ||
| 6399 | public final EObject ruleFieldRelationInterpretation() throws RecognitionException { | ||
| 6400 | EObject current = null; | ||
| 6401 | 8615 | ||
| 6402 | Token lv_containment_0_0=null; | ||
| 6403 | Token otherlv_2=null; | ||
| 6404 | EObject lv_symbol_1_0 = null; | ||
| 6405 | |||
| 6406 | EObject lv_multiplicity_3_0 = null; | ||
| 6407 | 8616 | ||
| 6408 | EObject lv_target_4_0 = null; | 8617 | // $ANTLR start "ruleUpperMultiplicty" |
| 8618 | // InternalSolverLanguageParser.g:3356:1: ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= Asterisk ) ; | ||
| 8619 | public final AntlrDatatypeRuleToken ruleUpperMultiplicty() throws RecognitionException { | ||
| 8620 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
| 6409 | 8621 | ||
| 8622 | Token this_INT_0=null; | ||
| 8623 | Token kw=null; | ||
| 6410 | 8624 | ||
| 6411 | 8625 | ||
| 6412 | enterRule(); | 8626 | enterRule(); |
| 6413 | 8627 | ||
| 6414 | try { | 8628 | try { |
| 6415 | // InternalSolverLanguage.g:2205:2: ( ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ) | 8629 | // InternalSolverLanguageParser.g:3362:2: ( (this_INT_0= RULE_INT | kw= Asterisk ) ) |
| 6416 | // InternalSolverLanguage.g:2206:2: ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) | 8630 | // InternalSolverLanguageParser.g:3363:2: (this_INT_0= RULE_INT | kw= Asterisk ) |
| 6417 | { | 8631 | { |
| 6418 | // InternalSolverLanguage.g:2206:2: ( ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) | 8632 | // InternalSolverLanguageParser.g:3363:2: (this_INT_0= RULE_INT | kw= Asterisk ) |
| 6419 | // InternalSolverLanguage.g:2207:3: ( (lv_containment_0_0= 'containment' ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) | 8633 | int alt40=2; |
| 6420 | { | 8634 | int LA40_0 = input.LA(1); |
| 6421 | // InternalSolverLanguage.g:2207:3: ( (lv_containment_0_0= 'containment' ) )? | ||
| 6422 | int alt42=2; | ||
| 6423 | int LA42_0 = input.LA(1); | ||
| 6424 | 8635 | ||
| 6425 | if ( (LA42_0==39) ) { | 8636 | if ( (LA40_0==RULE_INT) ) { |
| 6426 | alt42=1; | 8637 | alt40=1; |
| 8638 | } | ||
| 8639 | else if ( (LA40_0==Asterisk) ) { | ||
| 8640 | alt40=2; | ||
| 6427 | } | 8641 | } |
| 6428 | switch (alt42) { | 8642 | else { |
| 8643 | NoViableAltException nvae = | ||
| 8644 | new NoViableAltException("", 40, 0, input); | ||
| 8645 | |||
| 8646 | throw nvae; | ||
| 8647 | } | ||
| 8648 | switch (alt40) { | ||
| 6429 | case 1 : | 8649 | case 1 : |
| 6430 | // InternalSolverLanguage.g:2208:4: (lv_containment_0_0= 'containment' ) | 8650 | // InternalSolverLanguageParser.g:3364:3: this_INT_0= RULE_INT |
| 6431 | { | ||
| 6432 | // InternalSolverLanguage.g:2208:4: (lv_containment_0_0= 'containment' ) | ||
| 6433 | // InternalSolverLanguage.g:2209:5: lv_containment_0_0= 'containment' | ||
| 6434 | { | 8651 | { |
| 6435 | lv_containment_0_0=(Token)match(input,39,FOLLOW_12); | 8652 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); |
| 6436 | 8653 | ||
| 6437 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 8654 | current.merge(this_INT_0); |
| 6438 | 8655 | ||
| 6439 | 8656 | ||
| 6440 | if (current==null) { | 8657 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
| 6441 | current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); | 8658 | |
| 6442 | } | ||
| 6443 | setWithLastConsumed(current, "containment", true, "containment"); | ||
| 6444 | |||
| 6445 | 8659 | ||
| 6446 | } | 8660 | } |
| 8661 | break; | ||
| 8662 | case 2 : | ||
| 8663 | // InternalSolverLanguageParser.g:3372:3: kw= Asterisk | ||
| 8664 | { | ||
| 8665 | kw=(Token)match(input,Asterisk,FOLLOW_2); | ||
| 6447 | 8666 | ||
| 8667 | current.merge(kw); | ||
| 8668 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
| 8669 | |||
| 6448 | 8670 | ||
| 6449 | } | 8671 | } |
| 6450 | break; | 8672 | break; |
| 6451 | 8673 | ||
| 6452 | } | 8674 | } |
| 6453 | 8675 | ||
| 6454 | // InternalSolverLanguage.g:2221:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) | ||
| 6455 | // InternalSolverLanguage.g:2222:4: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 6456 | { | ||
| 6457 | // InternalSolverLanguage.g:2222:4: (lv_symbol_1_0= ruleModelSymbol ) | ||
| 6458 | // InternalSolverLanguage.g:2223:5: lv_symbol_1_0= ruleModelSymbol | ||
| 6459 | { | ||
| 6460 | 8676 | ||
| 6461 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); | 8677 | } |
| 6462 | |||
| 6463 | pushFollow(FOLLOW_10); | ||
| 6464 | lv_symbol_1_0=ruleModelSymbol(); | ||
| 6465 | 8678 | ||
| 6466 | state._fsp--; | ||
| 6467 | 8679 | ||
| 8680 | leaveRule(); | ||
| 6468 | 8681 | ||
| 6469 | if (current==null) { | 8682 | } |
| 6470 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | ||
| 6471 | } | ||
| 6472 | set( | ||
| 6473 | current, | ||
| 6474 | "symbol", | ||
| 6475 | lv_symbol_1_0, | ||
| 6476 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6477 | afterParserOrEnumRuleCall(); | ||
| 6478 | |||
| 6479 | 8683 | ||
| 8684 | catch (RecognitionException re) { | ||
| 8685 | recover(input,re); | ||
| 8686 | appendSkippedTokens(); | ||
| 6480 | } | 8687 | } |
| 8688 | finally { | ||
| 8689 | } | ||
| 8690 | return current; | ||
| 8691 | } | ||
| 8692 | // $ANTLR end "ruleUpperMultiplicty" | ||
| 6481 | 8693 | ||
| 6482 | 8694 | ||
| 6483 | } | 8695 | // $ANTLR start "entryRuleReal" |
| 8696 | // InternalSolverLanguageParser.g:3381:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; | ||
| 8697 | public final String entryRuleReal() throws RecognitionException { | ||
| 8698 | String current = null; | ||
| 6484 | 8699 | ||
| 6485 | otherlv_2=(Token)match(input,20,FOLLOW_33); | 8700 | AntlrDatatypeRuleToken iv_ruleReal = null; |
| 6486 | 8701 | ||
| 6487 | newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); | ||
| 6488 | |||
| 6489 | // InternalSolverLanguage.g:2244:3: ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? | ||
| 6490 | int alt43=2; | ||
| 6491 | int LA43_0 = input.LA(1); | ||
| 6492 | 8702 | ||
| 6493 | if ( (LA43_0==RULE_INT) ) { | 8703 | |
| 6494 | alt43=1; | 8704 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| 8705 | |||
| 8706 | try { | ||
| 8707 | // InternalSolverLanguageParser.g:3383:2: (iv_ruleReal= ruleReal EOF ) | ||
| 8708 | // InternalSolverLanguageParser.g:3384:2: iv_ruleReal= ruleReal EOF | ||
| 8709 | { | ||
| 8710 | newCompositeNode(grammarAccess.getRealRule()); | ||
| 8711 | pushFollow(FOLLOW_1); | ||
| 8712 | iv_ruleReal=ruleReal(); | ||
| 8713 | |||
| 8714 | state._fsp--; | ||
| 8715 | |||
| 8716 | current =iv_ruleReal.getText(); | ||
| 8717 | match(input,EOF,FOLLOW_2); | ||
| 8718 | |||
| 6495 | } | 8719 | } |
| 6496 | switch (alt43) { | ||
| 6497 | case 1 : | ||
| 6498 | // InternalSolverLanguage.g:2245:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) | ||
| 6499 | { | ||
| 6500 | // InternalSolverLanguage.g:2245:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) | ||
| 6501 | // InternalSolverLanguage.g:2246:5: lv_multiplicity_3_0= ruleMultiplicityDefinition | ||
| 6502 | { | ||
| 6503 | 8720 | ||
| 6504 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); | 8721 | } |
| 6505 | |||
| 6506 | pushFollow(FOLLOW_21); | ||
| 6507 | lv_multiplicity_3_0=ruleMultiplicityDefinition(); | ||
| 6508 | 8722 | ||
| 6509 | state._fsp--; | 8723 | catch (RecognitionException re) { |
| 8724 | recover(input,re); | ||
| 8725 | appendSkippedTokens(); | ||
| 8726 | } | ||
| 8727 | finally { | ||
| 6510 | 8728 | ||
| 8729 | myHiddenTokenState.restore(); | ||
| 6511 | 8730 | ||
| 6512 | if (current==null) { | 8731 | } |
| 6513 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | 8732 | return current; |
| 6514 | } | 8733 | } |
| 6515 | set( | 8734 | // $ANTLR end "entryRuleReal" |
| 6516 | current, | ||
| 6517 | "multiplicity", | ||
| 6518 | lv_multiplicity_3_0, | ||
| 6519 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | ||
| 6520 | afterParserOrEnumRuleCall(); | ||
| 6521 | |||
| 6522 | 8735 | ||
| 6523 | } | ||
| 6524 | 8736 | ||
| 8737 | // $ANTLR start "ruleReal" | ||
| 8738 | // InternalSolverLanguageParser.g:3393:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) ; | ||
| 8739 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { | ||
| 8740 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
| 8741 | |||
| 8742 | Token this_INT_0=null; | ||
| 8743 | Token kw=null; | ||
| 8744 | Token this_INT_2=null; | ||
| 6525 | 8745 | ||
| 6526 | } | ||
| 6527 | break; | ||
| 6528 | 8746 | ||
| 6529 | } | 8747 | enterRule(); |
| 8748 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 6530 | 8749 | ||
| 6531 | // InternalSolverLanguage.g:2263:3: ( (lv_target_4_0= ruleSymbol ) ) | 8750 | try { |
| 6532 | // InternalSolverLanguage.g:2264:4: (lv_target_4_0= ruleSymbol ) | 8751 | // InternalSolverLanguageParser.g:3400:2: ( (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) ) |
| 8752 | // InternalSolverLanguageParser.g:3401:2: (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) | ||
| 6533 | { | 8753 | { |
| 6534 | // InternalSolverLanguage.g:2264:4: (lv_target_4_0= ruleSymbol ) | 8754 | // InternalSolverLanguageParser.g:3401:2: (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) |
| 6535 | // InternalSolverLanguage.g:2265:5: lv_target_4_0= ruleSymbol | 8755 | // InternalSolverLanguageParser.g:3402:3: this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? |
| 6536 | { | 8756 | { |
| 8757 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_51); | ||
| 6537 | 8758 | ||
| 6538 | newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); | 8759 | current.merge(this_INT_0); |
| 6539 | 8760 | ||
| 6540 | pushFollow(FOLLOW_2); | ||
| 6541 | lv_target_4_0=ruleSymbol(); | ||
| 6542 | 8761 | ||
| 6543 | state._fsp--; | 8762 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
| 8763 | |||
| 8764 | // InternalSolverLanguageParser.g:3409:3: (kw= FullStop this_INT_2= RULE_INT )? | ||
| 8765 | int alt41=2; | ||
| 8766 | int LA41_0 = input.LA(1); | ||
| 6544 | 8767 | ||
| 8768 | if ( (LA41_0==FullStop) ) { | ||
| 8769 | alt41=1; | ||
| 8770 | } | ||
| 8771 | switch (alt41) { | ||
| 8772 | case 1 : | ||
| 8773 | // InternalSolverLanguageParser.g:3410:4: kw= FullStop this_INT_2= RULE_INT | ||
| 8774 | { | ||
| 8775 | kw=(Token)match(input,FullStop,FOLLOW_45); | ||
| 6545 | 8776 | ||
| 6546 | if (current==null) { | 8777 | current.merge(kw); |
| 6547 | current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); | 8778 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
| 6548 | } | 8779 | |
| 6549 | set( | 8780 | this_INT_2=(Token)match(input,RULE_INT,FOLLOW_2); |
| 6550 | current, | ||
| 6551 | "target", | ||
| 6552 | lv_target_4_0, | ||
| 6553 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 6554 | afterParserOrEnumRuleCall(); | ||
| 6555 | |||
| 6556 | 8781 | ||
| 6557 | } | 8782 | current.merge(this_INT_2); |
| 8783 | |||
| 6558 | 8784 | ||
| 8785 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | ||
| 8786 | |||
| 8787 | |||
| 8788 | } | ||
| 8789 | break; | ||
| 6559 | 8790 | ||
| 6560 | } | 8791 | } |
| 6561 | 8792 | ||
| @@ -6575,31 +8806,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6575 | appendSkippedTokens(); | 8806 | appendSkippedTokens(); |
| 6576 | } | 8807 | } |
| 6577 | finally { | 8808 | finally { |
| 8809 | |||
| 8810 | myHiddenTokenState.restore(); | ||
| 8811 | |||
| 6578 | } | 8812 | } |
| 6579 | return current; | 8813 | return current; |
| 6580 | } | 8814 | } |
| 6581 | // $ANTLR end "ruleFieldRelationInterpretation" | 8815 | // $ANTLR end "ruleReal" |
| 6582 | 8816 | ||
| 6583 | 8817 | ||
| 6584 | // $ANTLR start "entryRuleGlobalRelationInterpretation" | 8818 | // $ANTLR start "entryRuleQualifiedName" |
| 6585 | // InternalSolverLanguage.g:2286:1: entryRuleGlobalRelationInterpretation returns [EObject current=null] : iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ; | 8819 | // InternalSolverLanguageParser.g:3430:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; |
| 6586 | public final EObject entryRuleGlobalRelationInterpretation() throws RecognitionException { | 8820 | public final String entryRuleQualifiedName() throws RecognitionException { |
| 6587 | EObject current = null; | 8821 | String current = null; |
| 8822 | |||
| 8823 | AntlrDatatypeRuleToken iv_ruleQualifiedName = null; | ||
| 6588 | 8824 | ||
| 6589 | EObject iv_ruleGlobalRelationInterpretation = null; | ||
| 6590 | 8825 | ||
| 6591 | 8826 | ||
| 8827 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 8828 | |||
| 6592 | try { | 8829 | try { |
| 6593 | // InternalSolverLanguage.g:2286:69: (iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ) | 8830 | // InternalSolverLanguageParser.g:3432:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) |
| 6594 | // InternalSolverLanguage.g:2287:2: iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF | 8831 | // InternalSolverLanguageParser.g:3433:2: iv_ruleQualifiedName= ruleQualifiedName EOF |
| 6595 | { | 8832 | { |
| 6596 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); | 8833 | newCompositeNode(grammarAccess.getQualifiedNameRule()); |
| 6597 | pushFollow(FOLLOW_1); | 8834 | pushFollow(FOLLOW_1); |
| 6598 | iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation(); | 8835 | iv_ruleQualifiedName=ruleQualifiedName(); |
| 6599 | 8836 | ||
| 6600 | state._fsp--; | 8837 | state._fsp--; |
| 6601 | 8838 | ||
| 6602 | current =iv_ruleGlobalRelationInterpretation; | 8839 | current =iv_ruleQualifiedName.getText(); |
| 6603 | match(input,EOF,FOLLOW_2); | 8840 | match(input,EOF,FOLLOW_2); |
| 6604 | 8841 | ||
| 6605 | } | 8842 | } |
| @@ -6611,65 +8848,203 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6611 | appendSkippedTokens(); | 8848 | appendSkippedTokens(); |
| 6612 | } | 8849 | } |
| 6613 | finally { | 8850 | finally { |
| 8851 | |||
| 8852 | myHiddenTokenState.restore(); | ||
| 8853 | |||
| 6614 | } | 8854 | } |
| 6615 | return current; | 8855 | return current; |
| 6616 | } | 8856 | } |
| 6617 | // $ANTLR end "entryRuleGlobalRelationInterpretation" | 8857 | // $ANTLR end "entryRuleQualifiedName" |
| 6618 | 8858 | ||
| 6619 | 8859 | ||
| 6620 | // $ANTLR start "ruleGlobalRelationInterpretation" | 8860 | // $ANTLR start "ruleQualifiedName" |
| 6621 | // InternalSolverLanguage.g:2293:1: ruleGlobalRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) )? otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ; | 8861 | // InternalSolverLanguageParser.g:3442:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ; |
| 6622 | public final EObject ruleGlobalRelationInterpretation() throws RecognitionException { | 8862 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { |
| 6623 | EObject current = null; | 8863 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
| 6624 | 8864 | ||
| 6625 | Token lv_containment_0_0=null; | 8865 | Token this_ID_0=null; |
| 6626 | Token otherlv_1=null; | 8866 | Token kw=null; |
| 6627 | Token otherlv_3=null; | 8867 | Token this_ID_2=null; |
| 6628 | EObject lv_symbol_2_0 = null; | 8868 | Token this_QUOTED_ID_3=null; |
| 8869 | |||
| 8870 | |||
| 8871 | enterRule(); | ||
| 8872 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
| 8873 | |||
| 8874 | try { | ||
| 8875 | // InternalSolverLanguageParser.g:3449:2: ( ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ) | ||
| 8876 | // InternalSolverLanguageParser.g:3450:2: ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) | ||
| 8877 | { | ||
| 8878 | // InternalSolverLanguageParser.g:3450:2: ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) | ||
| 8879 | int alt43=2; | ||
| 8880 | int LA43_0 = input.LA(1); | ||
| 8881 | |||
| 8882 | if ( (LA43_0==RULE_ID) ) { | ||
| 8883 | alt43=1; | ||
| 8884 | } | ||
| 8885 | else if ( (LA43_0==RULE_QUOTED_ID) ) { | ||
| 8886 | alt43=2; | ||
| 8887 | } | ||
| 8888 | else { | ||
| 8889 | NoViableAltException nvae = | ||
| 8890 | new NoViableAltException("", 43, 0, input); | ||
| 8891 | |||
| 8892 | throw nvae; | ||
| 8893 | } | ||
| 8894 | switch (alt43) { | ||
| 8895 | case 1 : | ||
| 8896 | // InternalSolverLanguageParser.g:3451:3: (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | ||
| 8897 | { | ||
| 8898 | // InternalSolverLanguageParser.g:3451:3: (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | ||
| 8899 | // InternalSolverLanguageParser.g:3452:4: this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* | ||
| 8900 | { | ||
| 8901 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_51); | ||
| 8902 | |||
| 8903 | current.merge(this_ID_0); | ||
| 8904 | |||
| 8905 | |||
| 8906 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | ||
| 8907 | |||
| 8908 | // InternalSolverLanguageParser.g:3459:4: (kw= FullStop this_ID_2= RULE_ID )* | ||
| 8909 | loop42: | ||
| 8910 | do { | ||
| 8911 | int alt42=2; | ||
| 8912 | int LA42_0 = input.LA(1); | ||
| 8913 | |||
| 8914 | if ( (LA42_0==FullStop) ) { | ||
| 8915 | alt42=1; | ||
| 8916 | } | ||
| 8917 | |||
| 8918 | |||
| 8919 | switch (alt42) { | ||
| 8920 | case 1 : | ||
| 8921 | // InternalSolverLanguageParser.g:3460:5: kw= FullStop this_ID_2= RULE_ID | ||
| 8922 | { | ||
| 8923 | kw=(Token)match(input,FullStop,FOLLOW_38); | ||
| 8924 | |||
| 8925 | current.merge(kw); | ||
| 8926 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | ||
| 8927 | |||
| 8928 | this_ID_2=(Token)match(input,RULE_ID,FOLLOW_51); | ||
| 8929 | |||
| 8930 | current.merge(this_ID_2); | ||
| 8931 | |||
| 8932 | |||
| 8933 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | ||
| 8934 | |||
| 8935 | |||
| 8936 | } | ||
| 8937 | break; | ||
| 8938 | |||
| 8939 | default : | ||
| 8940 | break loop42; | ||
| 8941 | } | ||
| 8942 | } while (true); | ||
| 8943 | |||
| 8944 | |||
| 8945 | } | ||
| 8946 | |||
| 8947 | |||
| 8948 | } | ||
| 8949 | break; | ||
| 8950 | case 2 : | ||
| 8951 | // InternalSolverLanguageParser.g:3475:3: this_QUOTED_ID_3= RULE_QUOTED_ID | ||
| 8952 | { | ||
| 8953 | this_QUOTED_ID_3=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); | ||
| 8954 | |||
| 8955 | current.merge(this_QUOTED_ID_3); | ||
| 8956 | |||
| 8957 | |||
| 8958 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
| 8959 | |||
| 6629 | 8960 | ||
| 6630 | EObject lv_sourceMultiplicity_4_0 = null; | 8961 | } |
| 8962 | break; | ||
| 8963 | |||
| 8964 | } | ||
| 8965 | |||
| 8966 | |||
| 8967 | } | ||
| 8968 | |||
| 8969 | |||
| 8970 | leaveRule(); | ||
| 8971 | |||
| 8972 | } | ||
| 8973 | |||
| 8974 | catch (RecognitionException re) { | ||
| 8975 | recover(input,re); | ||
| 8976 | appendSkippedTokens(); | ||
| 8977 | } | ||
| 8978 | finally { | ||
| 8979 | |||
| 8980 | myHiddenTokenState.restore(); | ||
| 6631 | 8981 | ||
| 6632 | EObject lv_source_5_0 = null; | 8982 | } |
| 8983 | return current; | ||
| 8984 | } | ||
| 8985 | // $ANTLR end "ruleQualifiedName" | ||
| 6633 | 8986 | ||
| 6634 | EObject lv_targetMultiplicity_6_0 = null; | ||
| 6635 | 8987 | ||
| 6636 | EObject lv_target_7_0 = null; | 8988 | // $ANTLR start "ruleMetricType" |
| 8989 | // InternalSolverLanguageParser.g:3489:1: ruleMetricType returns [Enumerator current=null] : ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) ; | ||
| 8990 | public final Enumerator ruleMetricType() throws RecognitionException { | ||
| 8991 | Enumerator current = null; | ||
| 6637 | 8992 | ||
| 8993 | Token enumLiteral_0=null; | ||
| 8994 | Token enumLiteral_1=null; | ||
| 6638 | 8995 | ||
| 6639 | 8996 | ||
| 6640 | enterRule(); | 8997 | enterRule(); |
| 6641 | 8998 | ||
| 6642 | try { | 8999 | try { |
| 6643 | // InternalSolverLanguage.g:2299:2: ( ( ( (lv_containment_0_0= 'containment' ) )? otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ) | 9000 | // InternalSolverLanguageParser.g:3495:2: ( ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) ) |
| 6644 | // InternalSolverLanguage.g:2300:2: ( ( (lv_containment_0_0= 'containment' ) )? otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) | 9001 | // InternalSolverLanguageParser.g:3496:2: ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) |
| 6645 | { | 9002 | { |
| 6646 | // InternalSolverLanguage.g:2300:2: ( ( (lv_containment_0_0= 'containment' ) )? otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) | 9003 | // InternalSolverLanguageParser.g:3496:2: ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) |
| 6647 | // InternalSolverLanguage.g:2301:3: ( (lv_containment_0_0= 'containment' ) )? otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) | ||
| 6648 | { | ||
| 6649 | // InternalSolverLanguage.g:2301:3: ( (lv_containment_0_0= 'containment' ) )? | ||
| 6650 | int alt44=2; | 9004 | int alt44=2; |
| 6651 | int LA44_0 = input.LA(1); | 9005 | int LA44_0 = input.LA(1); |
| 6652 | 9006 | ||
| 6653 | if ( (LA44_0==39) ) { | 9007 | if ( (LA44_0==Int) ) { |
| 6654 | alt44=1; | 9008 | alt44=1; |
| 6655 | } | 9009 | } |
| 9010 | else if ( (LA44_0==Real) ) { | ||
| 9011 | alt44=2; | ||
| 9012 | } | ||
| 9013 | else { | ||
| 9014 | NoViableAltException nvae = | ||
| 9015 | new NoViableAltException("", 44, 0, input); | ||
| 9016 | |||
| 9017 | throw nvae; | ||
| 9018 | } | ||
| 6656 | switch (alt44) { | 9019 | switch (alt44) { |
| 6657 | case 1 : | 9020 | case 1 : |
| 6658 | // InternalSolverLanguage.g:2302:4: (lv_containment_0_0= 'containment' ) | 9021 | // InternalSolverLanguageParser.g:3497:3: (enumLiteral_0= Int ) |
| 6659 | { | 9022 | { |
| 6660 | // InternalSolverLanguage.g:2302:4: (lv_containment_0_0= 'containment' ) | 9023 | // InternalSolverLanguageParser.g:3497:3: (enumLiteral_0= Int ) |
| 6661 | // InternalSolverLanguage.g:2303:5: lv_containment_0_0= 'containment' | 9024 | // InternalSolverLanguageParser.g:3498:4: enumLiteral_0= Int |
| 6662 | { | 9025 | { |
| 6663 | lv_containment_0_0=(Token)match(input,39,FOLLOW_34); | 9026 | enumLiteral_0=(Token)match(input,Int,FOLLOW_2); |
| 6664 | 9027 | ||
| 6665 | newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); | 9028 | current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 6666 | 9029 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | |
| 9030 | |||
| 9031 | |||
| 9032 | } | ||
| 6667 | 9033 | ||
| 6668 | if (current==null) { | 9034 | |
| 6669 | current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); | 9035 | } |
| 6670 | } | 9036 | break; |
| 6671 | setWithLastConsumed(current, "containment", true, "containment"); | 9037 | case 2 : |
| 6672 | 9038 | // InternalSolverLanguageParser.g:3505:3: (enumLiteral_1= Real ) | |
| 9039 | { | ||
| 9040 | // InternalSolverLanguageParser.g:3505:3: (enumLiteral_1= Real ) | ||
| 9041 | // InternalSolverLanguageParser.g:3506:4: enumLiteral_1= Real | ||
| 9042 | { | ||
| 9043 | enumLiteral_1=(Token)match(input,Real,FOLLOW_2); | ||
| 9044 | |||
| 9045 | current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9046 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | ||
| 9047 | |||
| 6673 | 9048 | ||
| 6674 | } | 9049 | } |
| 6675 | 9050 | ||
| @@ -6679,151 +9054,292 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6679 | 9054 | ||
| 6680 | } | 9055 | } |
| 6681 | 9056 | ||
| 6682 | otherlv_1=(Token)match(input,40,FOLLOW_12); | ||
| 6683 | |||
| 6684 | newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); | ||
| 6685 | |||
| 6686 | // InternalSolverLanguage.g:2319:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) | ||
| 6687 | // InternalSolverLanguage.g:2320:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6688 | { | ||
| 6689 | // InternalSolverLanguage.g:2320:4: (lv_symbol_2_0= ruleModelSymbol ) | ||
| 6690 | // InternalSolverLanguage.g:2321:5: lv_symbol_2_0= ruleModelSymbol | ||
| 6691 | { | ||
| 6692 | 9057 | ||
| 6693 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); | 9058 | } |
| 6694 | |||
| 6695 | pushFollow(FOLLOW_10); | ||
| 6696 | lv_symbol_2_0=ruleModelSymbol(); | ||
| 6697 | 9059 | ||
| 6698 | state._fsp--; | ||
| 6699 | 9060 | ||
| 9061 | leaveRule(); | ||
| 6700 | 9062 | ||
| 6701 | if (current==null) { | 9063 | } |
| 6702 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 6703 | } | ||
| 6704 | set( | ||
| 6705 | current, | ||
| 6706 | "symbol", | ||
| 6707 | lv_symbol_2_0, | ||
| 6708 | "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | ||
| 6709 | afterParserOrEnumRuleCall(); | ||
| 6710 | |||
| 6711 | 9064 | ||
| 9065 | catch (RecognitionException re) { | ||
| 9066 | recover(input,re); | ||
| 9067 | appendSkippedTokens(); | ||
| 6712 | } | 9068 | } |
| 9069 | finally { | ||
| 9070 | } | ||
| 9071 | return current; | ||
| 9072 | } | ||
| 9073 | // $ANTLR end "ruleMetricType" | ||
| 6713 | 9074 | ||
| 6714 | 9075 | ||
| 6715 | } | 9076 | // $ANTLR start "ruleComparisonOperator" |
| 9077 | // InternalSolverLanguageParser.g:3516:1: ruleComparisonOperator returns [Enumerator current=null] : ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ; | ||
| 9078 | public final Enumerator ruleComparisonOperator() throws RecognitionException { | ||
| 9079 | Enumerator current = null; | ||
| 6716 | 9080 | ||
| 6717 | otherlv_3=(Token)match(input,20,FOLLOW_33); | 9081 | Token enumLiteral_0=null; |
| 9082 | Token enumLiteral_1=null; | ||
| 9083 | Token enumLiteral_2=null; | ||
| 9084 | Token enumLiteral_3=null; | ||
| 9085 | Token enumLiteral_4=null; | ||
| 9086 | Token enumLiteral_5=null; | ||
| 9087 | Token enumLiteral_6=null; | ||
| 6718 | 9088 | ||
| 6719 | newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); | ||
| 6720 | |||
| 6721 | // InternalSolverLanguage.g:2342:3: ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? | ||
| 6722 | int alt45=2; | ||
| 6723 | int LA45_0 = input.LA(1); | ||
| 6724 | 9089 | ||
| 6725 | if ( (LA45_0==RULE_INT) ) { | 9090 | enterRule(); |
| 9091 | |||
| 9092 | try { | ||
| 9093 | // InternalSolverLanguageParser.g:3522:2: ( ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ) | ||
| 9094 | // InternalSolverLanguageParser.g:3523:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) | ||
| 9095 | { | ||
| 9096 | // InternalSolverLanguageParser.g:3523:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) | ||
| 9097 | int alt45=7; | ||
| 9098 | switch ( input.LA(1) ) { | ||
| 9099 | case EqualsSignEqualsSign: | ||
| 9100 | { | ||
| 6726 | alt45=1; | 9101 | alt45=1; |
| 9102 | } | ||
| 9103 | break; | ||
| 9104 | case ExclamationMarkEqualsSign: | ||
| 9105 | { | ||
| 9106 | alt45=2; | ||
| 9107 | } | ||
| 9108 | break; | ||
| 9109 | case LessThanSign: | ||
| 9110 | { | ||
| 9111 | alt45=3; | ||
| 9112 | } | ||
| 9113 | break; | ||
| 9114 | case LessThanSignEqualsSign: | ||
| 9115 | { | ||
| 9116 | alt45=4; | ||
| 9117 | } | ||
| 9118 | break; | ||
| 9119 | case GreaterThanSign: | ||
| 9120 | { | ||
| 9121 | alt45=5; | ||
| 9122 | } | ||
| 9123 | break; | ||
| 9124 | case GreaterThanSignEqualsSign: | ||
| 9125 | { | ||
| 9126 | alt45=6; | ||
| 9127 | } | ||
| 9128 | break; | ||
| 9129 | case In: | ||
| 9130 | { | ||
| 9131 | alt45=7; | ||
| 9132 | } | ||
| 9133 | break; | ||
| 9134 | default: | ||
| 9135 | NoViableAltException nvae = | ||
| 9136 | new NoViableAltException("", 45, 0, input); | ||
| 9137 | |||
| 9138 | throw nvae; | ||
| 6727 | } | 9139 | } |
| 9140 | |||
| 6728 | switch (alt45) { | 9141 | switch (alt45) { |
| 6729 | case 1 : | 9142 | case 1 : |
| 6730 | // InternalSolverLanguage.g:2343:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) | 9143 | // InternalSolverLanguageParser.g:3524:3: (enumLiteral_0= EqualsSignEqualsSign ) |
| 6731 | { | 9144 | { |
| 6732 | // InternalSolverLanguage.g:2343:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) | 9145 | // InternalSolverLanguageParser.g:3524:3: (enumLiteral_0= EqualsSignEqualsSign ) |
| 6733 | // InternalSolverLanguage.g:2344:5: lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition | 9146 | // InternalSolverLanguageParser.g:3525:4: enumLiteral_0= EqualsSignEqualsSign |
| 6734 | { | 9147 | { |
| 9148 | enumLiteral_0=(Token)match(input,EqualsSignEqualsSign,FOLLOW_2); | ||
| 6735 | 9149 | ||
| 6736 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); | 9150 | current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 6737 | 9151 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | |
| 6738 | pushFollow(FOLLOW_21); | 9152 | |
| 6739 | lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition(); | ||
| 6740 | 9153 | ||
| 6741 | state._fsp--; | 9154 | } |
| 6742 | 9155 | ||
| 6743 | 9156 | ||
| 6744 | if (current==null) { | 9157 | } |
| 6745 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 9158 | break; |
| 6746 | } | 9159 | case 2 : |
| 6747 | set( | 9160 | // InternalSolverLanguageParser.g:3532:3: (enumLiteral_1= ExclamationMarkEqualsSign ) |
| 6748 | current, | 9161 | { |
| 6749 | "sourceMultiplicity", | 9162 | // InternalSolverLanguageParser.g:3532:3: (enumLiteral_1= ExclamationMarkEqualsSign ) |
| 6750 | lv_sourceMultiplicity_4_0, | 9163 | // InternalSolverLanguageParser.g:3533:4: enumLiteral_1= ExclamationMarkEqualsSign |
| 6751 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | 9164 | { |
| 6752 | afterParserOrEnumRuleCall(); | 9165 | enumLiteral_1=(Token)match(input,ExclamationMarkEqualsSign,FOLLOW_2); |
| 6753 | 9166 | ||
| 9167 | current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9168 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | ||
| 9169 | |||
| 6754 | 9170 | ||
| 6755 | } | 9171 | } |
| 6756 | 9172 | ||
| 6757 | 9173 | ||
| 6758 | } | 9174 | } |
| 6759 | break; | 9175 | break; |
| 9176 | case 3 : | ||
| 9177 | // InternalSolverLanguageParser.g:3540:3: (enumLiteral_2= LessThanSign ) | ||
| 9178 | { | ||
| 9179 | // InternalSolverLanguageParser.g:3540:3: (enumLiteral_2= LessThanSign ) | ||
| 9180 | // InternalSolverLanguageParser.g:3541:4: enumLiteral_2= LessThanSign | ||
| 9181 | { | ||
| 9182 | enumLiteral_2=(Token)match(input,LessThanSign,FOLLOW_2); | ||
| 6760 | 9183 | ||
| 6761 | } | 9184 | current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
| 9185 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
| 9186 | |||
| 6762 | 9187 | ||
| 6763 | // InternalSolverLanguage.g:2361:3: ( (lv_source_5_0= ruleSymbol ) ) | 9188 | } |
| 6764 | // InternalSolverLanguage.g:2362:4: (lv_source_5_0= ruleSymbol ) | ||
| 6765 | { | ||
| 6766 | // InternalSolverLanguage.g:2362:4: (lv_source_5_0= ruleSymbol ) | ||
| 6767 | // InternalSolverLanguage.g:2363:5: lv_source_5_0= ruleSymbol | ||
| 6768 | { | ||
| 6769 | 9189 | ||
| 6770 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); | ||
| 6771 | |||
| 6772 | pushFollow(FOLLOW_33); | ||
| 6773 | lv_source_5_0=ruleSymbol(); | ||
| 6774 | 9190 | ||
| 6775 | state._fsp--; | 9191 | } |
| 9192 | break; | ||
| 9193 | case 4 : | ||
| 9194 | // InternalSolverLanguageParser.g:3548:3: (enumLiteral_3= LessThanSignEqualsSign ) | ||
| 9195 | { | ||
| 9196 | // InternalSolverLanguageParser.g:3548:3: (enumLiteral_3= LessThanSignEqualsSign ) | ||
| 9197 | // InternalSolverLanguageParser.g:3549:4: enumLiteral_3= LessThanSignEqualsSign | ||
| 9198 | { | ||
| 9199 | enumLiteral_3=(Token)match(input,LessThanSignEqualsSign,FOLLOW_2); | ||
| 6776 | 9200 | ||
| 9201 | current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 9202 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | ||
| 9203 | |||
| 6777 | 9204 | ||
| 6778 | if (current==null) { | 9205 | } |
| 6779 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 9206 | |
| 6780 | } | 9207 | |
| 6781 | set( | 9208 | } |
| 6782 | current, | 9209 | break; |
| 6783 | "source", | 9210 | case 5 : |
| 6784 | lv_source_5_0, | 9211 | // InternalSolverLanguageParser.g:3556:3: (enumLiteral_4= GreaterThanSign ) |
| 6785 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 9212 | { |
| 6786 | afterParserOrEnumRuleCall(); | 9213 | // InternalSolverLanguageParser.g:3556:3: (enumLiteral_4= GreaterThanSign ) |
| 6787 | 9214 | // InternalSolverLanguageParser.g:3557:4: enumLiteral_4= GreaterThanSign | |
| 9215 | { | ||
| 9216 | enumLiteral_4=(Token)match(input,GreaterThanSign,FOLLOW_2); | ||
| 9217 | |||
| 9218 | current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 9219 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
| 9220 | |||
| 9221 | |||
| 9222 | } | ||
| 9223 | |||
| 9224 | |||
| 9225 | } | ||
| 9226 | break; | ||
| 9227 | case 6 : | ||
| 9228 | // InternalSolverLanguageParser.g:3564:3: (enumLiteral_5= GreaterThanSignEqualsSign ) | ||
| 9229 | { | ||
| 9230 | // InternalSolverLanguageParser.g:3564:3: (enumLiteral_5= GreaterThanSignEqualsSign ) | ||
| 9231 | // InternalSolverLanguageParser.g:3565:4: enumLiteral_5= GreaterThanSignEqualsSign | ||
| 9232 | { | ||
| 9233 | enumLiteral_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_2); | ||
| 9234 | |||
| 9235 | current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 9236 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | ||
| 9237 | |||
| 9238 | |||
| 9239 | } | ||
| 9240 | |||
| 9241 | |||
| 9242 | } | ||
| 9243 | break; | ||
| 9244 | case 7 : | ||
| 9245 | // InternalSolverLanguageParser.g:3572:3: (enumLiteral_6= In ) | ||
| 9246 | { | ||
| 9247 | // InternalSolverLanguageParser.g:3572:3: (enumLiteral_6= In ) | ||
| 9248 | // InternalSolverLanguageParser.g:3573:4: enumLiteral_6= In | ||
| 9249 | { | ||
| 9250 | enumLiteral_6=(Token)match(input,In,FOLLOW_2); | ||
| 9251 | |||
| 9252 | current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
| 9253 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
| 9254 | |||
| 9255 | |||
| 9256 | } | ||
| 9257 | |||
| 9258 | |||
| 9259 | } | ||
| 9260 | break; | ||
| 6788 | 9261 | ||
| 6789 | } | 9262 | } |
| 6790 | 9263 | ||
| 6791 | 9264 | ||
| 6792 | } | 9265 | } |
| 6793 | 9266 | ||
| 6794 | // InternalSolverLanguage.g:2380:3: ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? | 9267 | |
| 9268 | leaveRule(); | ||
| 9269 | |||
| 9270 | } | ||
| 9271 | |||
| 9272 | catch (RecognitionException re) { | ||
| 9273 | recover(input,re); | ||
| 9274 | appendSkippedTokens(); | ||
| 9275 | } | ||
| 9276 | finally { | ||
| 9277 | } | ||
| 9278 | return current; | ||
| 9279 | } | ||
| 9280 | // $ANTLR end "ruleComparisonOperator" | ||
| 9281 | |||
| 9282 | |||
| 9283 | // $ANTLR start "ruleAdditiveBinaryOperator" | ||
| 9284 | // InternalSolverLanguageParser.g:3583:1: ruleAdditiveBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ; | ||
| 9285 | public final Enumerator ruleAdditiveBinaryOperator() throws RecognitionException { | ||
| 9286 | Enumerator current = null; | ||
| 9287 | |||
| 9288 | Token enumLiteral_0=null; | ||
| 9289 | Token enumLiteral_1=null; | ||
| 9290 | |||
| 9291 | |||
| 9292 | enterRule(); | ||
| 9293 | |||
| 9294 | try { | ||
| 9295 | // InternalSolverLanguageParser.g:3589:2: ( ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ) | ||
| 9296 | // InternalSolverLanguageParser.g:3590:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) | ||
| 9297 | { | ||
| 9298 | // InternalSolverLanguageParser.g:3590:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) | ||
| 6795 | int alt46=2; | 9299 | int alt46=2; |
| 6796 | int LA46_0 = input.LA(1); | 9300 | int LA46_0 = input.LA(1); |
| 6797 | 9301 | ||
| 6798 | if ( (LA46_0==RULE_INT) ) { | 9302 | if ( (LA46_0==PlusSign) ) { |
| 6799 | alt46=1; | 9303 | alt46=1; |
| 6800 | } | 9304 | } |
| 9305 | else if ( (LA46_0==HyphenMinus) ) { | ||
| 9306 | alt46=2; | ||
| 9307 | } | ||
| 9308 | else { | ||
| 9309 | NoViableAltException nvae = | ||
| 9310 | new NoViableAltException("", 46, 0, input); | ||
| 9311 | |||
| 9312 | throw nvae; | ||
| 9313 | } | ||
| 6801 | switch (alt46) { | 9314 | switch (alt46) { |
| 6802 | case 1 : | 9315 | case 1 : |
| 6803 | // InternalSolverLanguage.g:2381:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) | 9316 | // InternalSolverLanguageParser.g:3591:3: (enumLiteral_0= PlusSign ) |
| 6804 | { | 9317 | { |
| 6805 | // InternalSolverLanguage.g:2381:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) | 9318 | // InternalSolverLanguageParser.g:3591:3: (enumLiteral_0= PlusSign ) |
| 6806 | // InternalSolverLanguage.g:2382:5: lv_targetMultiplicity_6_0= ruleMultiplicityDefinition | 9319 | // InternalSolverLanguageParser.g:3592:4: enumLiteral_0= PlusSign |
| 6807 | { | 9320 | { |
| 9321 | enumLiteral_0=(Token)match(input,PlusSign,FOLLOW_2); | ||
| 6808 | 9322 | ||
| 6809 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); | 9323 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
| 6810 | 9324 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | |
| 6811 | pushFollow(FOLLOW_21); | 9325 | |
| 6812 | lv_targetMultiplicity_6_0=ruleMultiplicityDefinition(); | ||
| 6813 | 9326 | ||
| 6814 | state._fsp--; | 9327 | } |
| 6815 | 9328 | ||
| 6816 | 9329 | ||
| 6817 | if (current==null) { | 9330 | } |
| 6818 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | 9331 | break; |
| 6819 | } | 9332 | case 2 : |
| 6820 | set( | 9333 | // InternalSolverLanguageParser.g:3599:3: (enumLiteral_1= HyphenMinus ) |
| 6821 | current, | 9334 | { |
| 6822 | "targetMultiplicity", | 9335 | // InternalSolverLanguageParser.g:3599:3: (enumLiteral_1= HyphenMinus ) |
| 6823 | lv_targetMultiplicity_6_0, | 9336 | // InternalSolverLanguageParser.g:3600:4: enumLiteral_1= HyphenMinus |
| 6824 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | 9337 | { |
| 6825 | afterParserOrEnumRuleCall(); | 9338 | enumLiteral_1=(Token)match(input,HyphenMinus,FOLLOW_2); |
| 6826 | 9339 | ||
| 9340 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9341 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | ||
| 9342 | |||
| 6827 | 9343 | ||
| 6828 | } | 9344 | } |
| 6829 | 9345 | ||
| @@ -6833,38 +9349,92 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6833 | 9349 | ||
| 6834 | } | 9350 | } |
| 6835 | 9351 | ||
| 6836 | // InternalSolverLanguage.g:2399:3: ( (lv_target_7_0= ruleSymbol ) ) | ||
| 6837 | // InternalSolverLanguage.g:2400:4: (lv_target_7_0= ruleSymbol ) | ||
| 6838 | { | ||
| 6839 | // InternalSolverLanguage.g:2400:4: (lv_target_7_0= ruleSymbol ) | ||
| 6840 | // InternalSolverLanguage.g:2401:5: lv_target_7_0= ruleSymbol | ||
| 6841 | { | ||
| 6842 | 9352 | ||
| 6843 | newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); | 9353 | } |
| 6844 | |||
| 6845 | pushFollow(FOLLOW_2); | ||
| 6846 | lv_target_7_0=ruleSymbol(); | ||
| 6847 | 9354 | ||
| 6848 | state._fsp--; | ||
| 6849 | 9355 | ||
| 9356 | leaveRule(); | ||
| 6850 | 9357 | ||
| 6851 | if (current==null) { | 9358 | } |
| 6852 | current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); | ||
| 6853 | } | ||
| 6854 | set( | ||
| 6855 | current, | ||
| 6856 | "target", | ||
| 6857 | lv_target_7_0, | ||
| 6858 | "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | ||
| 6859 | afterParserOrEnumRuleCall(); | ||
| 6860 | |||
| 6861 | 9359 | ||
| 9360 | catch (RecognitionException re) { | ||
| 9361 | recover(input,re); | ||
| 9362 | appendSkippedTokens(); | ||
| 6862 | } | 9363 | } |
| 9364 | finally { | ||
| 9365 | } | ||
| 9366 | return current; | ||
| 9367 | } | ||
| 9368 | // $ANTLR end "ruleAdditiveBinaryOperator" | ||
| 9369 | |||
| 9370 | |||
| 9371 | // $ANTLR start "ruleMultiplicativeBinaryOperator" | ||
| 9372 | // InternalSolverLanguageParser.g:3610:1: ruleMultiplicativeBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ; | ||
| 9373 | public final Enumerator ruleMultiplicativeBinaryOperator() throws RecognitionException { | ||
| 9374 | Enumerator current = null; | ||
| 9375 | |||
| 9376 | Token enumLiteral_0=null; | ||
| 9377 | Token enumLiteral_1=null; | ||
| 9378 | |||
| 9379 | |||
| 9380 | enterRule(); | ||
| 6863 | 9381 | ||
| 9382 | try { | ||
| 9383 | // InternalSolverLanguageParser.g:3616:2: ( ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ) | ||
| 9384 | // InternalSolverLanguageParser.g:3617:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) | ||
| 9385 | { | ||
| 9386 | // InternalSolverLanguageParser.g:3617:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) | ||
| 9387 | int alt47=2; | ||
| 9388 | int LA47_0 = input.LA(1); | ||
| 9389 | |||
| 9390 | if ( (LA47_0==Asterisk) ) { | ||
| 9391 | alt47=1; | ||
| 9392 | } | ||
| 9393 | else if ( (LA47_0==Solidus) ) { | ||
| 9394 | alt47=2; | ||
| 9395 | } | ||
| 9396 | else { | ||
| 9397 | NoViableAltException nvae = | ||
| 9398 | new NoViableAltException("", 47, 0, input); | ||
| 6864 | 9399 | ||
| 9400 | throw nvae; | ||
| 6865 | } | 9401 | } |
| 9402 | switch (alt47) { | ||
| 9403 | case 1 : | ||
| 9404 | // InternalSolverLanguageParser.g:3618:3: (enumLiteral_0= Asterisk ) | ||
| 9405 | { | ||
| 9406 | // InternalSolverLanguageParser.g:3618:3: (enumLiteral_0= Asterisk ) | ||
| 9407 | // InternalSolverLanguageParser.g:3619:4: enumLiteral_0= Asterisk | ||
| 9408 | { | ||
| 9409 | enumLiteral_0=(Token)match(input,Asterisk,FOLLOW_2); | ||
| 9410 | |||
| 9411 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 9412 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | ||
| 9413 | |||
| 9414 | |||
| 9415 | } | ||
| 6866 | 9416 | ||
| 6867 | 9417 | ||
| 9418 | } | ||
| 9419 | break; | ||
| 9420 | case 2 : | ||
| 9421 | // InternalSolverLanguageParser.g:3626:3: (enumLiteral_1= Solidus ) | ||
| 9422 | { | ||
| 9423 | // InternalSolverLanguageParser.g:3626:3: (enumLiteral_1= Solidus ) | ||
| 9424 | // InternalSolverLanguageParser.g:3627:4: enumLiteral_1= Solidus | ||
| 9425 | { | ||
| 9426 | enumLiteral_1=(Token)match(input,Solidus,FOLLOW_2); | ||
| 9427 | |||
| 9428 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9429 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | ||
| 9430 | |||
| 9431 | |||
| 9432 | } | ||
| 9433 | |||
| 9434 | |||
| 9435 | } | ||
| 9436 | break; | ||
| 9437 | |||
| 6868 | } | 9438 | } |
| 6869 | 9439 | ||
| 6870 | 9440 | ||
| @@ -6883,32 +9453,40 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6883 | } | 9453 | } |
| 6884 | return current; | 9454 | return current; |
| 6885 | } | 9455 | } |
| 6886 | // $ANTLR end "ruleGlobalRelationInterpretation" | 9456 | // $ANTLR end "ruleMultiplicativeBinaryOperator" |
| 6887 | 9457 | ||
| 6888 | 9458 | ||
| 6889 | // $ANTLR start "entryRuleMultiplicityDefinition" | 9459 | // $ANTLR start "ruleExponentialOp" |
| 6890 | // InternalSolverLanguage.g:2422:1: entryRuleMultiplicityDefinition returns [EObject current=null] : iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ; | 9460 | // InternalSolverLanguageParser.g:3637:1: ruleExponentialOp returns [Enumerator current=null] : (enumLiteral_0= CircumflexAccent ) ; |
| 6891 | public final EObject entryRuleMultiplicityDefinition() throws RecognitionException { | 9461 | public final Enumerator ruleExponentialOp() throws RecognitionException { |
| 6892 | EObject current = null; | 9462 | Enumerator current = null; |
| 6893 | 9463 | ||
| 6894 | EObject iv_ruleMultiplicityDefinition = null; | 9464 | Token enumLiteral_0=null; |
| 6895 | 9465 | ||
| 6896 | 9466 | ||
| 9467 | enterRule(); | ||
| 9468 | |||
| 6897 | try { | 9469 | try { |
| 6898 | // InternalSolverLanguage.g:2422:63: (iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ) | 9470 | // InternalSolverLanguageParser.g:3643:2: ( (enumLiteral_0= CircumflexAccent ) ) |
| 6899 | // InternalSolverLanguage.g:2423:2: iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF | 9471 | // InternalSolverLanguageParser.g:3644:2: (enumLiteral_0= CircumflexAccent ) |
| 6900 | { | 9472 | { |
| 6901 | newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); | 9473 | // InternalSolverLanguageParser.g:3644:2: (enumLiteral_0= CircumflexAccent ) |
| 6902 | pushFollow(FOLLOW_1); | 9474 | // InternalSolverLanguageParser.g:3645:3: enumLiteral_0= CircumflexAccent |
| 6903 | iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition(); | 9475 | { |
| 9476 | enumLiteral_0=(Token)match(input,CircumflexAccent,FOLLOW_2); | ||
| 6904 | 9477 | ||
| 6905 | state._fsp--; | 9478 | current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); |
| 9479 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
| 9480 | |||
| 9481 | |||
| 9482 | } | ||
| 6906 | 9483 | ||
| 6907 | current =iv_ruleMultiplicityDefinition; | ||
| 6908 | match(input,EOF,FOLLOW_2); | ||
| 6909 | 9484 | ||
| 6910 | } | 9485 | } |
| 6911 | 9486 | ||
| 9487 | |||
| 9488 | leaveRule(); | ||
| 9489 | |||
| 6912 | } | 9490 | } |
| 6913 | 9491 | ||
| 6914 | catch (RecognitionException re) { | 9492 | catch (RecognitionException re) { |
| @@ -6919,102 +9497,436 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 6919 | } | 9497 | } |
| 6920 | return current; | 9498 | return current; |
| 6921 | } | 9499 | } |
| 6922 | // $ANTLR end "entryRuleMultiplicityDefinition" | 9500 | // $ANTLR end "ruleExponentialOp" |
| 6923 | 9501 | ||
| 6924 | 9502 | ||
| 6925 | // $ANTLR start "ruleMultiplicityDefinition" | 9503 | // $ANTLR start "ruleUnaryOp" |
| 6926 | // InternalSolverLanguage.g:2429:1: ruleMultiplicityDefinition returns [EObject current=null] : ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ; | 9504 | // InternalSolverLanguageParser.g:3654:1: ruleUnaryOp returns [Enumerator current=null] : ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) ; |
| 6927 | public final EObject ruleMultiplicityDefinition() throws RecognitionException { | 9505 | public final Enumerator ruleUnaryOp() throws RecognitionException { |
| 6928 | EObject current = null; | 9506 | Enumerator current = null; |
| 6929 | 9507 | ||
| 6930 | Token lv_lower_0_0=null; | 9508 | Token enumLiteral_0=null; |
| 6931 | Token otherlv_1=null; | 9509 | Token enumLiteral_1=null; |
| 6932 | Token lv_upper_2_0=null; | 9510 | Token enumLiteral_2=null; |
| 6933 | Token lv_unlimitedUpper_3_0=null; | 9511 | Token enumLiteral_3=null; |
| 9512 | Token enumLiteral_4=null; | ||
| 9513 | Token enumLiteral_5=null; | ||
| 6934 | 9514 | ||
| 6935 | 9515 | ||
| 6936 | enterRule(); | 9516 | enterRule(); |
| 6937 | 9517 | ||
| 6938 | try { | 9518 | try { |
| 6939 | // InternalSolverLanguage.g:2435:2: ( ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ) | 9519 | // InternalSolverLanguageParser.g:3660:2: ( ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) ) |
| 6940 | // InternalSolverLanguage.g:2436:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) | 9520 | // InternalSolverLanguageParser.g:3661:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) |
| 6941 | { | ||
| 6942 | // InternalSolverLanguage.g:2436:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) | ||
| 6943 | // InternalSolverLanguage.g:2437:3: ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) | ||
| 6944 | { | 9521 | { |
| 6945 | // InternalSolverLanguage.g:2437:3: ( (lv_lower_0_0= RULE_INT ) ) | 9522 | // InternalSolverLanguageParser.g:3661:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) |
| 6946 | // InternalSolverLanguage.g:2438:4: (lv_lower_0_0= RULE_INT ) | 9523 | int alt48=6; |
| 6947 | { | 9524 | switch ( input.LA(1) ) { |
| 6948 | // InternalSolverLanguage.g:2438:4: (lv_lower_0_0= RULE_INT ) | 9525 | case ExclamationMark: |
| 6949 | // InternalSolverLanguage.g:2439:5: lv_lower_0_0= RULE_INT | 9526 | { |
| 6950 | { | 9527 | alt48=1; |
| 6951 | lv_lower_0_0=(Token)match(input,RULE_INT,FOLLOW_35); | 9528 | } |
| 9529 | break; | ||
| 9530 | case PlusSign: | ||
| 9531 | { | ||
| 9532 | alt48=2; | ||
| 9533 | } | ||
| 9534 | break; | ||
| 9535 | case HyphenMinus: | ||
| 9536 | { | ||
| 9537 | alt48=3; | ||
| 9538 | } | ||
| 9539 | break; | ||
| 9540 | case May: | ||
| 9541 | { | ||
| 9542 | alt48=4; | ||
| 9543 | } | ||
| 9544 | break; | ||
| 9545 | case Must: | ||
| 9546 | { | ||
| 9547 | alt48=5; | ||
| 9548 | } | ||
| 9549 | break; | ||
| 9550 | case Current: | ||
| 9551 | { | ||
| 9552 | alt48=6; | ||
| 9553 | } | ||
| 9554 | break; | ||
| 9555 | default: | ||
| 9556 | NoViableAltException nvae = | ||
| 9557 | new NoViableAltException("", 48, 0, input); | ||
| 6952 | 9558 | ||
| 6953 | newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); | 9559 | throw nvae; |
| 6954 | 9560 | } | |
| 9561 | |||
| 9562 | switch (alt48) { | ||
| 9563 | case 1 : | ||
| 9564 | // InternalSolverLanguageParser.g:3662:3: (enumLiteral_0= ExclamationMark ) | ||
| 9565 | { | ||
| 9566 | // InternalSolverLanguageParser.g:3662:3: (enumLiteral_0= ExclamationMark ) | ||
| 9567 | // InternalSolverLanguageParser.g:3663:4: enumLiteral_0= ExclamationMark | ||
| 9568 | { | ||
| 9569 | enumLiteral_0=(Token)match(input,ExclamationMark,FOLLOW_2); | ||
| 9570 | |||
| 9571 | current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 9572 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | ||
| 9573 | |||
| 9574 | |||
| 9575 | } | ||
| 6955 | 9576 | ||
| 6956 | if (current==null) { | 9577 | |
| 6957 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | 9578 | } |
| 6958 | } | 9579 | break; |
| 6959 | setWithLastConsumed( | 9580 | case 2 : |
| 6960 | current, | 9581 | // InternalSolverLanguageParser.g:3670:3: (enumLiteral_1= PlusSign ) |
| 6961 | "lower", | 9582 | { |
| 6962 | lv_lower_0_0, | 9583 | // InternalSolverLanguageParser.g:3670:3: (enumLiteral_1= PlusSign ) |
| 6963 | "org.eclipse.xtext.common.Terminals.INT"); | 9584 | // InternalSolverLanguageParser.g:3671:4: enumLiteral_1= PlusSign |
| 6964 | 9585 | { | |
| 9586 | enumLiteral_1=(Token)match(input,PlusSign,FOLLOW_2); | ||
| 9587 | |||
| 9588 | current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9589 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | ||
| 9590 | |||
| 9591 | |||
| 9592 | } | ||
| 9593 | |||
| 9594 | |||
| 9595 | } | ||
| 9596 | break; | ||
| 9597 | case 3 : | ||
| 9598 | // InternalSolverLanguageParser.g:3678:3: (enumLiteral_2= HyphenMinus ) | ||
| 9599 | { | ||
| 9600 | // InternalSolverLanguageParser.g:3678:3: (enumLiteral_2= HyphenMinus ) | ||
| 9601 | // InternalSolverLanguageParser.g:3679:4: enumLiteral_2= HyphenMinus | ||
| 9602 | { | ||
| 9603 | enumLiteral_2=(Token)match(input,HyphenMinus,FOLLOW_2); | ||
| 9604 | |||
| 9605 | current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 9606 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | ||
| 9607 | |||
| 9608 | |||
| 9609 | } | ||
| 9610 | |||
| 9611 | |||
| 9612 | } | ||
| 9613 | break; | ||
| 9614 | case 4 : | ||
| 9615 | // InternalSolverLanguageParser.g:3686:3: (enumLiteral_3= May ) | ||
| 9616 | { | ||
| 9617 | // InternalSolverLanguageParser.g:3686:3: (enumLiteral_3= May ) | ||
| 9618 | // InternalSolverLanguageParser.g:3687:4: enumLiteral_3= May | ||
| 9619 | { | ||
| 9620 | enumLiteral_3=(Token)match(input,May,FOLLOW_2); | ||
| 9621 | |||
| 9622 | current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 9623 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | ||
| 9624 | |||
| 9625 | |||
| 9626 | } | ||
| 9627 | |||
| 9628 | |||
| 9629 | } | ||
| 9630 | break; | ||
| 9631 | case 5 : | ||
| 9632 | // InternalSolverLanguageParser.g:3694:3: (enumLiteral_4= Must ) | ||
| 9633 | { | ||
| 9634 | // InternalSolverLanguageParser.g:3694:3: (enumLiteral_4= Must ) | ||
| 9635 | // InternalSolverLanguageParser.g:3695:4: enumLiteral_4= Must | ||
| 9636 | { | ||
| 9637 | enumLiteral_4=(Token)match(input,Must,FOLLOW_2); | ||
| 9638 | |||
| 9639 | current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 9640 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | ||
| 9641 | |||
| 9642 | |||
| 9643 | } | ||
| 9644 | |||
| 9645 | |||
| 9646 | } | ||
| 9647 | break; | ||
| 9648 | case 6 : | ||
| 9649 | // InternalSolverLanguageParser.g:3702:3: (enumLiteral_5= Current ) | ||
| 9650 | { | ||
| 9651 | // InternalSolverLanguageParser.g:3702:3: (enumLiteral_5= Current ) | ||
| 9652 | // InternalSolverLanguageParser.g:3703:4: enumLiteral_5= Current | ||
| 9653 | { | ||
| 9654 | enumLiteral_5=(Token)match(input,Current,FOLLOW_2); | ||
| 9655 | |||
| 9656 | current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 9657 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | ||
| 9658 | |||
| 9659 | |||
| 9660 | } | ||
| 9661 | |||
| 9662 | |||
| 9663 | } | ||
| 9664 | break; | ||
| 6965 | 9665 | ||
| 6966 | } | 9666 | } |
| 6967 | 9667 | ||
| 6968 | 9668 | ||
| 6969 | } | 9669 | } |
| 6970 | 9670 | ||
| 6971 | otherlv_1=(Token)match(input,41,FOLLOW_36); | ||
| 6972 | 9671 | ||
| 6973 | newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); | 9672 | leaveRule(); |
| 6974 | |||
| 6975 | // InternalSolverLanguage.g:2459:3: ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) | ||
| 6976 | int alt47=2; | ||
| 6977 | int LA47_0 = input.LA(1); | ||
| 6978 | 9673 | ||
| 6979 | if ( (LA47_0==RULE_INT) ) { | 9674 | } |
| 6980 | alt47=1; | 9675 | |
| 6981 | } | 9676 | catch (RecognitionException re) { |
| 6982 | else if ( (LA47_0==31) ) { | 9677 | recover(input,re); |
| 6983 | alt47=2; | 9678 | appendSkippedTokens(); |
| 6984 | } | 9679 | } |
| 6985 | else { | 9680 | finally { |
| 9681 | } | ||
| 9682 | return current; | ||
| 9683 | } | ||
| 9684 | // $ANTLR end "ruleUnaryOp" | ||
| 9685 | |||
| 9686 | |||
| 9687 | // $ANTLR start "ruleAggregationOp" | ||
| 9688 | // InternalSolverLanguageParser.g:3713:1: ruleAggregationOp returns [Enumerator current=null] : ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) ; | ||
| 9689 | public final Enumerator ruleAggregationOp() throws RecognitionException { | ||
| 9690 | Enumerator current = null; | ||
| 9691 | |||
| 9692 | Token enumLiteral_0=null; | ||
| 9693 | Token enumLiteral_1=null; | ||
| 9694 | Token enumLiteral_2=null; | ||
| 9695 | Token enumLiteral_3=null; | ||
| 9696 | Token enumLiteral_4=null; | ||
| 9697 | Token enumLiteral_5=null; | ||
| 9698 | |||
| 9699 | |||
| 9700 | enterRule(); | ||
| 9701 | |||
| 9702 | try { | ||
| 9703 | // InternalSolverLanguageParser.g:3719:2: ( ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) ) | ||
| 9704 | // InternalSolverLanguageParser.g:3720:2: ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) | ||
| 9705 | { | ||
| 9706 | // InternalSolverLanguageParser.g:3720:2: ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) | ||
| 9707 | int alt49=6; | ||
| 9708 | switch ( input.LA(1) ) { | ||
| 9709 | case Only: | ||
| 9710 | { | ||
| 9711 | alt49=1; | ||
| 9712 | } | ||
| 9713 | break; | ||
| 9714 | case Sum: | ||
| 9715 | { | ||
| 9716 | alt49=2; | ||
| 9717 | } | ||
| 9718 | break; | ||
| 9719 | case Prod: | ||
| 9720 | { | ||
| 9721 | alt49=3; | ||
| 9722 | } | ||
| 9723 | break; | ||
| 9724 | case Avg: | ||
| 9725 | { | ||
| 9726 | alt49=4; | ||
| 9727 | } | ||
| 9728 | break; | ||
| 9729 | case Min: | ||
| 9730 | { | ||
| 9731 | alt49=5; | ||
| 9732 | } | ||
| 9733 | break; | ||
| 9734 | case Max: | ||
| 9735 | { | ||
| 9736 | alt49=6; | ||
| 9737 | } | ||
| 9738 | break; | ||
| 9739 | default: | ||
| 6986 | NoViableAltException nvae = | 9740 | NoViableAltException nvae = |
| 6987 | new NoViableAltException("", 47, 0, input); | 9741 | new NoViableAltException("", 49, 0, input); |
| 6988 | 9742 | ||
| 6989 | throw nvae; | 9743 | throw nvae; |
| 6990 | } | 9744 | } |
| 6991 | switch (alt47) { | 9745 | |
| 9746 | switch (alt49) { | ||
| 6992 | case 1 : | 9747 | case 1 : |
| 6993 | // InternalSolverLanguage.g:2460:4: ( (lv_upper_2_0= RULE_INT ) ) | 9748 | // InternalSolverLanguageParser.g:3721:3: (enumLiteral_0= Only ) |
| 6994 | { | 9749 | { |
| 6995 | // InternalSolverLanguage.g:2460:4: ( (lv_upper_2_0= RULE_INT ) ) | 9750 | // InternalSolverLanguageParser.g:3721:3: (enumLiteral_0= Only ) |
| 6996 | // InternalSolverLanguage.g:2461:5: (lv_upper_2_0= RULE_INT ) | 9751 | // InternalSolverLanguageParser.g:3722:4: enumLiteral_0= Only |
| 6997 | { | 9752 | { |
| 6998 | // InternalSolverLanguage.g:2461:5: (lv_upper_2_0= RULE_INT ) | 9753 | enumLiteral_0=(Token)match(input,Only,FOLLOW_2); |
| 6999 | // InternalSolverLanguage.g:2462:6: lv_upper_2_0= RULE_INT | 9754 | |
| 9755 | current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 9756 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | ||
| 9757 | |||
| 9758 | |||
| 9759 | } | ||
| 9760 | |||
| 9761 | |||
| 9762 | } | ||
| 9763 | break; | ||
| 9764 | case 2 : | ||
| 9765 | // InternalSolverLanguageParser.g:3729:3: (enumLiteral_1= Sum ) | ||
| 7000 | { | 9766 | { |
| 7001 | lv_upper_2_0=(Token)match(input,RULE_INT,FOLLOW_2); | 9767 | // InternalSolverLanguageParser.g:3729:3: (enumLiteral_1= Sum ) |
| 9768 | // InternalSolverLanguageParser.g:3730:4: enumLiteral_1= Sum | ||
| 9769 | { | ||
| 9770 | enumLiteral_1=(Token)match(input,Sum,FOLLOW_2); | ||
| 7002 | 9771 | ||
| 7003 | newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); | 9772 | current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
| 7004 | 9773 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | |
| 9774 | |||
| 9775 | |||
| 9776 | } | ||
| 7005 | 9777 | ||
| 7006 | if (current==null) { | ||
| 7007 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 7008 | } | ||
| 7009 | setWithLastConsumed( | ||
| 7010 | current, | ||
| 7011 | "upper", | ||
| 7012 | lv_upper_2_0, | ||
| 7013 | "org.eclipse.xtext.common.Terminals.INT"); | ||
| 7014 | |||
| 7015 | 9778 | ||
| 7016 | } | 9779 | } |
| 9780 | break; | ||
| 9781 | case 3 : | ||
| 9782 | // InternalSolverLanguageParser.g:3737:3: (enumLiteral_2= Prod ) | ||
| 9783 | { | ||
| 9784 | // InternalSolverLanguageParser.g:3737:3: (enumLiteral_2= Prod ) | ||
| 9785 | // InternalSolverLanguageParser.g:3738:4: enumLiteral_2= Prod | ||
| 9786 | { | ||
| 9787 | enumLiteral_2=(Token)match(input,Prod,FOLLOW_2); | ||
| 9788 | |||
| 9789 | current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
| 9790 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | ||
| 9791 | |||
| 9792 | |||
| 9793 | } | ||
| 9794 | |||
| 9795 | |||
| 9796 | } | ||
| 9797 | break; | ||
| 9798 | case 4 : | ||
| 9799 | // InternalSolverLanguageParser.g:3745:3: (enumLiteral_3= Avg ) | ||
| 9800 | { | ||
| 9801 | // InternalSolverLanguageParser.g:3745:3: (enumLiteral_3= Avg ) | ||
| 9802 | // InternalSolverLanguageParser.g:3746:4: enumLiteral_3= Avg | ||
| 9803 | { | ||
| 9804 | enumLiteral_3=(Token)match(input,Avg,FOLLOW_2); | ||
| 9805 | |||
| 9806 | current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 9807 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | ||
| 9808 | |||
| 9809 | |||
| 9810 | } | ||
| 9811 | |||
| 9812 | |||
| 9813 | } | ||
| 9814 | break; | ||
| 9815 | case 5 : | ||
| 9816 | // InternalSolverLanguageParser.g:3753:3: (enumLiteral_4= Min ) | ||
| 9817 | { | ||
| 9818 | // InternalSolverLanguageParser.g:3753:3: (enumLiteral_4= Min ) | ||
| 9819 | // InternalSolverLanguageParser.g:3754:4: enumLiteral_4= Min | ||
| 9820 | { | ||
| 9821 | enumLiteral_4=(Token)match(input,Min,FOLLOW_2); | ||
| 9822 | |||
| 9823 | current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
| 9824 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | ||
| 9825 | |||
| 9826 | |||
| 9827 | } | ||
| 9828 | |||
| 9829 | |||
| 9830 | } | ||
| 9831 | break; | ||
| 9832 | case 6 : | ||
| 9833 | // InternalSolverLanguageParser.g:3761:3: (enumLiteral_5= Max ) | ||
| 9834 | { | ||
| 9835 | // InternalSolverLanguageParser.g:3761:3: (enumLiteral_5= Max ) | ||
| 9836 | // InternalSolverLanguageParser.g:3762:4: enumLiteral_5= Max | ||
| 9837 | { | ||
| 9838 | enumLiteral_5=(Token)match(input,Max,FOLLOW_2); | ||
| 9839 | |||
| 9840 | current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
| 9841 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | ||
| 9842 | |||
| 9843 | |||
| 9844 | } | ||
| 9845 | |||
| 9846 | |||
| 9847 | } | ||
| 9848 | break; | ||
| 9849 | |||
| 9850 | } | ||
| 9851 | |||
| 9852 | |||
| 9853 | } | ||
| 9854 | |||
| 9855 | |||
| 9856 | leaveRule(); | ||
| 9857 | |||
| 9858 | } | ||
| 9859 | |||
| 9860 | catch (RecognitionException re) { | ||
| 9861 | recover(input,re); | ||
| 9862 | appendSkippedTokens(); | ||
| 9863 | } | ||
| 9864 | finally { | ||
| 9865 | } | ||
| 9866 | return current; | ||
| 9867 | } | ||
| 9868 | // $ANTLR end "ruleAggregationOp" | ||
| 9869 | |||
| 9870 | |||
| 9871 | // $ANTLR start "ruleLogicValue" | ||
| 9872 | // InternalSolverLanguageParser.g:3772:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ; | ||
| 9873 | public final Enumerator ruleLogicValue() throws RecognitionException { | ||
| 9874 | Enumerator current = null; | ||
| 9875 | |||
| 9876 | Token enumLiteral_0=null; | ||
| 9877 | Token enumLiteral_1=null; | ||
| 9878 | Token enumLiteral_2=null; | ||
| 9879 | Token enumLiteral_3=null; | ||
| 9880 | |||
| 9881 | |||
| 9882 | enterRule(); | ||
| 9883 | |||
| 9884 | try { | ||
| 9885 | // InternalSolverLanguageParser.g:3778:2: ( ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ) | ||
| 9886 | // InternalSolverLanguageParser.g:3779:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) | ||
| 9887 | { | ||
| 9888 | // InternalSolverLanguageParser.g:3779:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) | ||
| 9889 | int alt50=4; | ||
| 9890 | switch ( input.LA(1) ) { | ||
| 9891 | case True: | ||
| 9892 | { | ||
| 9893 | alt50=1; | ||
| 9894 | } | ||
| 9895 | break; | ||
| 9896 | case False: | ||
| 9897 | { | ||
| 9898 | alt50=2; | ||
| 9899 | } | ||
| 9900 | break; | ||
| 9901 | case Unknown: | ||
| 9902 | { | ||
| 9903 | alt50=3; | ||
| 9904 | } | ||
| 9905 | break; | ||
| 9906 | case Error: | ||
| 9907 | { | ||
| 9908 | alt50=4; | ||
| 9909 | } | ||
| 9910 | break; | ||
| 9911 | default: | ||
| 9912 | NoViableAltException nvae = | ||
| 9913 | new NoViableAltException("", 50, 0, input); | ||
| 7017 | 9914 | ||
| 9915 | throw nvae; | ||
| 9916 | } | ||
| 9917 | |||
| 9918 | switch (alt50) { | ||
| 9919 | case 1 : | ||
| 9920 | // InternalSolverLanguageParser.g:3780:3: (enumLiteral_0= True ) | ||
| 9921 | { | ||
| 9922 | // InternalSolverLanguageParser.g:3780:3: (enumLiteral_0= True ) | ||
| 9923 | // InternalSolverLanguageParser.g:3781:4: enumLiteral_0= True | ||
| 9924 | { | ||
| 9925 | enumLiteral_0=(Token)match(input,True,FOLLOW_2); | ||
| 9926 | |||
| 9927 | current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 9928 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
| 9929 | |||
| 7018 | 9930 | ||
| 7019 | } | 9931 | } |
| 7020 | 9932 | ||
| @@ -7022,27 +9934,50 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7022 | } | 9934 | } |
| 7023 | break; | 9935 | break; |
| 7024 | case 2 : | 9936 | case 2 : |
| 7025 | // InternalSolverLanguage.g:2479:4: ( (lv_unlimitedUpper_3_0= '*' ) ) | 9937 | // InternalSolverLanguageParser.g:3788:3: (enumLiteral_1= False ) |
| 9938 | { | ||
| 9939 | // InternalSolverLanguageParser.g:3788:3: (enumLiteral_1= False ) | ||
| 9940 | // InternalSolverLanguageParser.g:3789:4: enumLiteral_1= False | ||
| 7026 | { | 9941 | { |
| 7027 | // InternalSolverLanguage.g:2479:4: ( (lv_unlimitedUpper_3_0= '*' ) ) | 9942 | enumLiteral_1=(Token)match(input,False,FOLLOW_2); |
| 7028 | // InternalSolverLanguage.g:2480:5: (lv_unlimitedUpper_3_0= '*' ) | 9943 | |
| 9944 | current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 9945 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
| 9946 | |||
| 9947 | |||
| 9948 | } | ||
| 9949 | |||
| 9950 | |||
| 9951 | } | ||
| 9952 | break; | ||
| 9953 | case 3 : | ||
| 9954 | // InternalSolverLanguageParser.g:3796:3: (enumLiteral_2= Unknown ) | ||
| 7029 | { | 9955 | { |
| 7030 | // InternalSolverLanguage.g:2480:5: (lv_unlimitedUpper_3_0= '*' ) | 9956 | // InternalSolverLanguageParser.g:3796:3: (enumLiteral_2= Unknown ) |
| 7031 | // InternalSolverLanguage.g:2481:6: lv_unlimitedUpper_3_0= '*' | 9957 | // InternalSolverLanguageParser.g:3797:4: enumLiteral_2= Unknown |
| 7032 | { | 9958 | { |
| 7033 | lv_unlimitedUpper_3_0=(Token)match(input,31,FOLLOW_2); | 9959 | enumLiteral_2=(Token)match(input,Unknown,FOLLOW_2); |
| 7034 | 9960 | ||
| 7035 | newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); | 9961 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
| 7036 | 9962 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | |
| 9963 | |||
| 9964 | |||
| 9965 | } | ||
| 7037 | 9966 | ||
| 7038 | if (current==null) { | ||
| 7039 | current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); | ||
| 7040 | } | ||
| 7041 | setWithLastConsumed(current, "unlimitedUpper", true, "*"); | ||
| 7042 | |||
| 7043 | 9967 | ||
| 7044 | } | 9968 | } |
| 9969 | break; | ||
| 9970 | case 4 : | ||
| 9971 | // InternalSolverLanguageParser.g:3804:3: (enumLiteral_3= Error ) | ||
| 9972 | { | ||
| 9973 | // InternalSolverLanguageParser.g:3804:3: (enumLiteral_3= Error ) | ||
| 9974 | // InternalSolverLanguageParser.g:3805:4: enumLiteral_3= Error | ||
| 9975 | { | ||
| 9976 | enumLiteral_3=(Token)match(input,Error,FOLLOW_2); | ||
| 7045 | 9977 | ||
| 9978 | current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
| 9979 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
| 9980 | |||
| 7046 | 9981 | ||
| 7047 | } | 9982 | } |
| 7048 | 9983 | ||
| @@ -7056,6 +9991,91 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7056 | } | 9991 | } |
| 7057 | 9992 | ||
| 7058 | 9993 | ||
| 9994 | leaveRule(); | ||
| 9995 | |||
| 9996 | } | ||
| 9997 | |||
| 9998 | catch (RecognitionException re) { | ||
| 9999 | recover(input,re); | ||
| 10000 | appendSkippedTokens(); | ||
| 10001 | } | ||
| 10002 | finally { | ||
| 10003 | } | ||
| 10004 | return current; | ||
| 10005 | } | ||
| 10006 | // $ANTLR end "ruleLogicValue" | ||
| 10007 | |||
| 10008 | |||
| 10009 | // $ANTLR start "ruleObjectiveKind" | ||
| 10010 | // InternalSolverLanguageParser.g:3815:1: ruleObjectiveKind returns [Enumerator current=null] : ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ; | ||
| 10011 | public final Enumerator ruleObjectiveKind() throws RecognitionException { | ||
| 10012 | Enumerator current = null; | ||
| 10013 | |||
| 10014 | Token enumLiteral_0=null; | ||
| 10015 | Token enumLiteral_1=null; | ||
| 10016 | |||
| 10017 | |||
| 10018 | enterRule(); | ||
| 10019 | |||
| 10020 | try { | ||
| 10021 | // InternalSolverLanguageParser.g:3821:2: ( ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ) | ||
| 10022 | // InternalSolverLanguageParser.g:3822:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) | ||
| 10023 | { | ||
| 10024 | // InternalSolverLanguageParser.g:3822:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) | ||
| 10025 | int alt51=2; | ||
| 10026 | int LA51_0 = input.LA(1); | ||
| 10027 | |||
| 10028 | if ( (LA51_0==Minimize) ) { | ||
| 10029 | alt51=1; | ||
| 10030 | } | ||
| 10031 | else if ( (LA51_0==Maximize) ) { | ||
| 10032 | alt51=2; | ||
| 10033 | } | ||
| 10034 | else { | ||
| 10035 | NoViableAltException nvae = | ||
| 10036 | new NoViableAltException("", 51, 0, input); | ||
| 10037 | |||
| 10038 | throw nvae; | ||
| 10039 | } | ||
| 10040 | switch (alt51) { | ||
| 10041 | case 1 : | ||
| 10042 | // InternalSolverLanguageParser.g:3823:3: (enumLiteral_0= Minimize ) | ||
| 10043 | { | ||
| 10044 | // InternalSolverLanguageParser.g:3823:3: (enumLiteral_0= Minimize ) | ||
| 10045 | // InternalSolverLanguageParser.g:3824:4: enumLiteral_0= Minimize | ||
| 10046 | { | ||
| 10047 | enumLiteral_0=(Token)match(input,Minimize,FOLLOW_2); | ||
| 10048 | |||
| 10049 | current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
| 10050 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | ||
| 10051 | |||
| 10052 | |||
| 10053 | } | ||
| 10054 | |||
| 10055 | |||
| 10056 | } | ||
| 10057 | break; | ||
| 10058 | case 2 : | ||
| 10059 | // InternalSolverLanguageParser.g:3831:3: (enumLiteral_1= Maximize ) | ||
| 10060 | { | ||
| 10061 | // InternalSolverLanguageParser.g:3831:3: (enumLiteral_1= Maximize ) | ||
| 10062 | // InternalSolverLanguageParser.g:3832:4: enumLiteral_1= Maximize | ||
| 10063 | { | ||
| 10064 | enumLiteral_1=(Token)match(input,Maximize,FOLLOW_2); | ||
| 10065 | |||
| 10066 | current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
| 10067 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | ||
| 10068 | |||
| 10069 | |||
| 10070 | } | ||
| 10071 | |||
| 10072 | |||
| 10073 | } | ||
| 10074 | break; | ||
| 10075 | |||
| 10076 | } | ||
| 10077 | |||
| 10078 | |||
| 7059 | } | 10079 | } |
| 7060 | 10080 | ||
| 7061 | 10081 | ||
| @@ -7071,27 +10091,34 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7071 | } | 10091 | } |
| 7072 | return current; | 10092 | return current; |
| 7073 | } | 10093 | } |
| 7074 | // $ANTLR end "ruleMultiplicityDefinition" | 10094 | // $ANTLR end "ruleObjectiveKind" |
| 7075 | 10095 | ||
| 7076 | // Delegated rules | 10096 | // Delegated rules |
| 7077 | 10097 | ||
| 7078 | 10098 | ||
| 7079 | protected DFA2 dfa2 = new DFA2(this); | 10099 | protected DFA2 dfa2 = new DFA2(this); |
| 7080 | static final String dfa_1s = "\11\uffff"; | 10100 | protected DFA20 dfa20 = new DFA20(this); |
| 7081 | static final String dfa_2s = "\1\5\1\21\2\uffff\1\4\1\22\1\24\1\4\1\22"; | 10101 | protected DFA24 dfa24 = new DFA24(this); |
| 7082 | static final String dfa_3s = "\1\50\1\34\2\uffff\1\37\1\24\1\34\1\37\1\24"; | 10102 | protected DFA35 dfa35 = new DFA35(this); |
| 7083 | static final String dfa_4s = "\2\uffff\1\1\1\2\5\uffff"; | 10103 | static final String dfa_1s = "\15\uffff"; |
| 7084 | static final String dfa_5s = "\11\uffff}>"; | 10104 | static final String dfa_2s = "\1\5\1\uffff\1\5\2\uffff\1\36\7\uffff"; |
| 10105 | static final String dfa_3s = "\1\123\1\uffff\1\122\2\uffff\1\122\7\uffff"; | ||
| 10106 | static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\1\4\1\uffff\1\6\1\10\1\11\1\12\1\3\1\5\1\7"; | ||
| 10107 | static final String dfa_5s = "\15\uffff}>"; | ||
| 7085 | static final String[] dfa_6s = { | 10108 | static final String[] dfa_6s = { |
| 7086 | "\1\1\12\uffff\1\3\4\uffff\6\2\5\uffff\3\2\3\uffff\3\2", | 10109 | "\1\3\1\7\1\uffff\2\11\3\uffff\1\1\1\4\1\uffff\1\1\1\uffff\1\5\1\7\2\1\1\2\1\1\1\10\2\uffff\3\1\1\6\1\uffff\1\1\5\uffff\2\1\1\6\4\1\11\uffff\1\1\1\uffff\2\1\2\uffff\1\1\1\uffff\1\1\7\uffff\1\1\5\uffff\2\1\4\uffff\2\1", |
| 7087 | "\1\4\2\uffff\1\2\7\uffff\1\3", | 10110 | "", |
| 10111 | "\1\3\47\uffff\2\1\1\uffff\4\1\3\uffff\1\1\1\uffff\1\12\1\uffff\4\1\1\uffff\6\1\2\uffff\1\1\4\uffff\1\3\3\uffff\1\1\1\3", | ||
| 10112 | "", | ||
| 10113 | "", | ||
| 10114 | "\1\14\11\uffff\1\14\44\uffff\1\13\4\uffff\1\13", | ||
| 7088 | "", | 10115 | "", |
| 7089 | "", | 10116 | "", |
| 7090 | "\1\2\1\5\1\2\4\uffff\1\2\1\uffff\2\2\4\uffff\1\6\1\2\6\uffff\1\2\3\uffff\1\2", | 10117 | "", |
| 7091 | "\1\7\1\6\1\3", | 10118 | "", |
| 7092 | "\1\2\7\uffff\1\3", | 10119 | "", |
| 7093 | "\1\2\1\10\1\2\4\uffff\1\2\1\uffff\2\2\5\uffff\1\2\6\uffff\1\2\3\uffff\1\2", | 10120 | "", |
| 7094 | "\1\7\1\6\1\3" | 10121 | "" |
| 7095 | }; | 10122 | }; |
| 7096 | 10123 | ||
| 7097 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | 10124 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
| @@ -7115,46 +10142,193 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
| 7115 | this.transition = dfa_6; | 10142 | this.transition = dfa_6; |
| 7116 | } | 10143 | } |
| 7117 | public String getDescription() { | 10144 | public String getDescription() { |
| 7118 | return "114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )"; | 10145 | return "109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition )"; |
| 10146 | } | ||
| 10147 | } | ||
| 10148 | static final String dfa_7s = "\12\uffff"; | ||
| 10149 | static final String dfa_8s = "\1\uffff\2\10\6\uffff\1\10"; | ||
| 10150 | static final String dfa_9s = "\1\20\2\32\3\uffff\1\122\2\uffff\1\32"; | ||
| 10151 | static final String dfa_10s = "\1\123\2\121\3\uffff\1\122\2\uffff\1\121"; | ||
| 10152 | static final String dfa_11s = "\3\uffff\1\3\1\4\1\5\1\uffff\1\2\1\1\1\uffff"; | ||
| 10153 | static final String dfa_12s = "\12\uffff}>"; | ||
| 10154 | static final String[] dfa_13s = { | ||
| 10155 | "\1\4\4\uffff\3\4\10\uffff\1\4\6\uffff\1\4\21\uffff\1\5\14\uffff\1\3\5\uffff\1\4\1\2\4\uffff\1\1\1\4", | ||
| 10156 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\6\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10", | ||
| 10157 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\uffff\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10", | ||
| 10158 | "", | ||
| 10159 | "", | ||
| 10160 | "", | ||
| 10161 | "\1\11", | ||
| 10162 | "", | ||
| 10163 | "", | ||
| 10164 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\6\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10" | ||
| 10165 | }; | ||
| 10166 | |||
| 10167 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | ||
| 10168 | static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); | ||
| 10169 | static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); | ||
| 10170 | static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); | ||
| 10171 | static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); | ||
| 10172 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | ||
| 10173 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); | ||
| 10174 | |||
| 10175 | class DFA20 extends DFA { | ||
| 10176 | |||
| 10177 | public DFA20(BaseRecognizer recognizer) { | ||
| 10178 | this.recognizer = recognizer; | ||
| 10179 | this.decisionNumber = 20; | ||
| 10180 | this.eot = dfa_7; | ||
| 10181 | this.eof = dfa_8; | ||
| 10182 | this.min = dfa_9; | ||
| 10183 | this.max = dfa_10; | ||
| 10184 | this.accept = dfa_11; | ||
| 10185 | this.special = dfa_12; | ||
| 10186 | this.transition = dfa_13; | ||
| 10187 | } | ||
| 10188 | public String getDescription() { | ||
| 10189 | return "1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) )"; | ||
| 10190 | } | ||
| 10191 | } | ||
| 10192 | static final String dfa_14s = "\1\uffff\2\3\3\uffff\1\11\1\uffff\1\3\1\uffff"; | ||
| 10193 | static final String dfa_15s = "\1\15\2\55\2\uffff\1\122\1\15\1\uffff\1\55\1\uffff"; | ||
| 10194 | static final String dfa_16s = "\1\123\2\122\2\uffff\1\122\1\123\1\uffff\1\122\1\uffff"; | ||
| 10195 | static final String dfa_17s = "\3\uffff\1\1\1\2\2\uffff\1\3\1\uffff\1\4"; | ||
| 10196 | static final String[] dfa_18s = { | ||
| 10197 | "\1\3\2\uffff\1\3\3\uffff\4\3\3\uffff\3\3\2\uffff\1\3\5\uffff\2\3\1\uffff\4\3\13\uffff\2\3\1\uffff\1\4\1\3\1\uffff\1\3\7\uffff\1\3\5\uffff\1\3\1\2\4\uffff\1\1\1\3", | ||
| 10198 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\5\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", | ||
| 10199 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\uffff\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", | ||
| 10200 | "", | ||
| 10201 | "", | ||
| 10202 | "\1\10", | ||
| 10203 | "\1\3\2\uffff\1\3\3\uffff\4\3\3\uffff\3\3\2\uffff\1\3\5\uffff\2\3\1\uffff\4\3\13\uffff\2\3\1\11\1\uffff\1\3\1\11\1\3\7\uffff\1\3\5\uffff\2\3\4\uffff\2\3", | ||
| 10204 | "", | ||
| 10205 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\5\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", | ||
| 10206 | "" | ||
| 10207 | }; | ||
| 10208 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
| 10209 | static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); | ||
| 10210 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
| 10211 | static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); | ||
| 10212 | static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); | ||
| 10213 | |||
| 10214 | class DFA24 extends DFA { | ||
| 10215 | |||
| 10216 | public DFA24(BaseRecognizer recognizer) { | ||
| 10217 | this.recognizer = recognizer; | ||
| 10218 | this.decisionNumber = 24; | ||
| 10219 | this.eot = dfa_7; | ||
| 10220 | this.eof = dfa_14; | ||
| 10221 | this.min = dfa_15; | ||
| 10222 | this.max = dfa_16; | ||
| 10223 | this.accept = dfa_17; | ||
| 10224 | this.special = dfa_12; | ||
| 10225 | this.transition = dfa_18; | ||
| 10226 | } | ||
| 10227 | public String getDescription() { | ||
| 10228 | return "1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument )"; | ||
| 10229 | } | ||
| 10230 | } | ||
| 10231 | static final String dfa_19s = "\17\uffff"; | ||
| 10232 | static final String dfa_20s = "\12\uffff\2\10\2\uffff\1\10"; | ||
| 10233 | static final String dfa_21s = "\1\30\1\115\3\61\1\115\1\uffff\1\122\2\uffff\3\61\1\122\1\61"; | ||
| 10234 | static final String dfa_22s = "\1\30\1\123\1\63\1\77\1\63\1\122\1\uffff\1\122\2\uffff\2\121\1\77\1\122\1\121"; | ||
| 10235 | static final String dfa_23s = "\6\uffff\1\2\1\uffff\1\3\1\1\5\uffff"; | ||
| 10236 | static final String dfa_24s = "\17\uffff}>"; | ||
| 10237 | static final String[] dfa_25s = { | ||
| 10238 | "\1\1", | ||
| 10239 | "\1\4\4\uffff\1\3\1\2", | ||
| 10240 | "\1\5\1\uffff\1\6", | ||
| 10241 | "\1\6\1\11\1\10\13\uffff\1\7", | ||
| 10242 | "\1\6\1\11\1\10", | ||
| 10243 | "\1\13\4\uffff\1\12", | ||
| 10244 | "", | ||
| 10245 | "\1\14", | ||
| 10246 | "", | ||
| 10247 | "", | ||
| 10248 | "\1\6\15\uffff\1\15\21\uffff\1\10", | ||
| 10249 | "\1\6\37\uffff\1\10", | ||
| 10250 | "\1\6\1\11\1\10\13\uffff\1\7", | ||
| 10251 | "\1\16", | ||
| 10252 | "\1\6\15\uffff\1\15\21\uffff\1\10" | ||
| 10253 | }; | ||
| 10254 | |||
| 10255 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); | ||
| 10256 | static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); | ||
| 10257 | static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); | ||
| 10258 | static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); | ||
| 10259 | static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); | ||
| 10260 | static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); | ||
| 10261 | static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); | ||
| 10262 | |||
| 10263 | class DFA35 extends DFA { | ||
| 10264 | |||
| 10265 | public DFA35(BaseRecognizer recognizer) { | ||
| 10266 | this.recognizer = recognizer; | ||
| 10267 | this.decisionNumber = 35; | ||
| 10268 | this.eot = dfa_19; | ||
| 10269 | this.eof = dfa_20; | ||
| 10270 | this.min = dfa_21; | ||
| 10271 | this.max = dfa_22; | ||
| 10272 | this.accept = dfa_23; | ||
| 10273 | this.special = dfa_24; | ||
| 10274 | this.transition = dfa_25; | ||
| 10275 | } | ||
| 10276 | public String getDescription() { | ||
| 10277 | return "2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition )"; | ||
| 7119 | } | 10278 | } |
| 7120 | } | 10279 | } |
| 7121 | 10280 | ||
| 7122 | 10281 | ||
| 7123 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 10282 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
| 7124 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 10283 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
| 7125 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000001C707E10022L}); | 10284 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x53401FC179FD6362L,0x00000000000C3040L}); |
| 7126 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); | 10285 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| 7127 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L}); | 10286 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0001000000000002L,0x0000000000000012L}); |
| 7128 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000120000L}); | 10287 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x53401EC138F12000L,0x00000000000C3040L}); |
| 7129 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000088186870L}); | 10288 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000400000L,0x0000000000042000L}); |
| 7130 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000000C0000L}); | 10289 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000000042000L}); |
| 7131 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000088106870L}); | 10290 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000020L,0x0000000000042000L}); |
| 7132 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000100000L}); | 10291 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0001000000000000L}); |
| 7133 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x000000000001E000L}); | 10292 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0200000000000000L}); |
| 7134 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000020L}); | 10293 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); |
| 7135 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000008000000L}); | 10294 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); |
| 7136 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000010020000L}); | 10295 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000010040000000L}); |
| 7137 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000080020L}); | 10296 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000080000000L}); |
| 7138 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000010000000L}); | 10297 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004000000L}); |
| 7139 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00000000E0007820L}); | 10298 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000400000000002L,0x0000000000000004L}); |
| 7140 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000020001000L}); | 10299 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L}); |
| 7141 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x00000000E0003820L}); | 10300 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000400000000000L}); |
| 7142 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000100002L}); | 10301 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x2000000000000002L}); |
| 7143 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000007E00020L}); | 10302 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x008E200000000002L,0x0000000000000028L}); |
| 7144 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x00000000C0000822L}); | 10303 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x5000000000000002L}); |
| 7145 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000020002L}); | 10304 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0800000000000002L,0x0000000000000001L}); |
| 7146 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x00000000080C6870L}); | 10305 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L}); |
| 7147 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000008006870L}); | 10306 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x02001AC130F10000L,0x00000000000C3040L}); |
| 7148 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000020000L}); | 10307 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); |
| 7149 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000400000000L}); | 10308 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); |
| 7150 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000001800000000L}); | 10309 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); |
| 7151 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001000000020L}); | 10310 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0400000000000000L}); |
| 7152 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x000000A000000020L}); | 10311 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0200000000000000L,0x0000000000018000L}); |
| 7153 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000001000000000L}); | 10312 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x5F401EC138F12000L,0x00000000000C3040L}); |
| 7154 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000002008000000L}); | 10313 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x2400000000000000L}); |
| 7155 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000007E00030L}); | 10314 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x5B401EC138F12000L,0x00000000000C3040L}); |
| 7156 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000010000000000L}); | 10315 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0800000000000000L}); |
| 7157 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000020000000000L}); | 10316 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000800000000000L}); |
| 7158 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000080000010L}); | 10317 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
| 10318 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000080000L}); | ||
| 10319 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); | ||
| 10320 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000200L}); | ||
| 10321 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000200L}); | ||
| 10322 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000080L,0x0000000000042800L}); | ||
| 10323 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040040L}); | ||
| 10324 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000402L,0x0000000000000004L}); | ||
| 10325 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0800000000000000L,0x0000000000080000L}); | ||
| 10326 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); | ||
| 10327 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0004000000000000L}); | ||
| 10328 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C2000L}); | ||
| 10329 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0002000000000000L}); | ||
| 10330 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0008000000000000L}); | ||
| 10331 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0008000000000002L}); | ||
| 10332 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000002L}); | ||
| 7159 | 10333 | ||
| 7160 | } \ No newline at end of file | 10334 | } \ No newline at end of file |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens new file mode 100644 index 00000000..81343db5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens | |||
| @@ -0,0 +1,83 @@ | |||
| 1 | '!'=56 | ||
| 2 | '!='=45 | ||
| 3 | '('=57 | ||
| 4 | ')'=58 | ||
| 5 | '*'=59 | ||
| 6 | '+'=60 | ||
| 7 | ','=61 | ||
| 8 | '-'=62 | ||
| 9 | '->'=46 | ||
| 10 | '.'=63 | ||
| 11 | '..'=47 | ||
| 12 | '/'=64 | ||
| 13 | ':'=65 | ||
| 14 | ':-'=48 | ||
| 15 | ';'=66 | ||
| 16 | '<'=67 | ||
| 17 | '<='=49 | ||
| 18 | '='=68 | ||
| 19 | '=='=50 | ||
| 20 | '>'=69 | ||
| 21 | '>='=51 | ||
| 22 | 'ADD'=33 | ||
| 23 | 'DIV'=34 | ||
| 24 | 'EQ'=52 | ||
| 25 | 'GREATER'=11 | ||
| 26 | 'GREATER_EQ'=4 | ||
| 27 | 'IN'=53 | ||
| 28 | 'LESS'=25 | ||
| 29 | 'LESS_EQ'=12 | ||
| 30 | 'MUL'=35 | ||
| 31 | 'NOT_EQ'=17 | ||
| 32 | 'POW'=36 | ||
| 33 | 'SUB'=37 | ||
| 34 | '['=70 | ||
| 35 | ']'=71 | ||
| 36 | '^'=72 | ||
| 37 | 'abstract'=6 | ||
| 38 | 'avg'=38 | ||
| 39 | 'class'=19 | ||
| 40 | 'contains'=7 | ||
| 41 | 'count'=20 | ||
| 42 | 'current'=13 | ||
| 43 | 'default'=14 | ||
| 44 | 'else'=26 | ||
| 45 | 'empty'=21 | ||
| 46 | 'error'=22 | ||
| 47 | 'extends'=15 | ||
| 48 | 'extern'=18 | ||
| 49 | 'false'=23 | ||
| 50 | 'functional'=5 | ||
| 51 | 'if'=54 | ||
| 52 | 'in'=55 | ||
| 53 | 'inf'=39 | ||
| 54 | 'int'=40 | ||
| 55 | 'max'=41 | ||
| 56 | 'maximize'=8 | ||
| 57 | 'may'=42 | ||
| 58 | 'min'=43 | ||
| 59 | 'minimize'=9 | ||
| 60 | 'must'=27 | ||
| 61 | 'only'=28 | ||
| 62 | 'opposite'=10 | ||
| 63 | 'prod'=29 | ||
| 64 | 'real'=30 | ||
| 65 | 'scope'=24 | ||
| 66 | 'sum'=44 | ||
| 67 | 'then'=31 | ||
| 68 | 'true'=32 | ||
| 69 | 'unknown'=16 | ||
| 70 | '{'=73 | ||
| 71 | '|'=74 | ||
| 72 | '}'=75 | ||
| 73 | RULE_ANY_OTHER=86 | ||
| 74 | RULE_FULL_STOP=81 | ||
| 75 | RULE_ID=82 | ||
| 76 | RULE_INT=83 | ||
| 77 | RULE_ML_COMMENT=84 | ||
| 78 | RULE_QUOTED_ID=77 | ||
| 79 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80 | ||
| 80 | RULE_SL_COMMENT=78 | ||
| 81 | RULE_STRING=76 | ||
| 82 | RULE_TRANSITIVE_CLOSURE=79 | ||
| 83 | RULE_WS=85 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g new file mode 100644 index 00000000..1a29e53b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g | |||
| @@ -0,0 +1,178 @@ | |||
| 1 | /* | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | lexer grammar InternalSolverLanguageLexer; | ||
| 5 | |||
| 6 | @header { | ||
| 7 | package org.eclipse.viatra.solver.language.parser.antlr.lexer; | ||
| 8 | |||
| 9 | // Hack: Use our own Lexer superclass by means of import. | ||
| 10 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 11 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 12 | } | ||
| 13 | |||
| 14 | GREATER_EQ : 'GREATER_EQ'; | ||
| 15 | |||
| 16 | Functional : 'functional'; | ||
| 17 | |||
| 18 | Abstract : 'abstract'; | ||
| 19 | |||
| 20 | Contains : 'contains'; | ||
| 21 | |||
| 22 | Maximize : 'maximize'; | ||
| 23 | |||
| 24 | Minimize : 'minimize'; | ||
| 25 | |||
| 26 | Opposite : 'opposite'; | ||
| 27 | |||
| 28 | GREATER : 'GREATER'; | ||
| 29 | |||
| 30 | LESS_EQ : 'LESS_EQ'; | ||
| 31 | |||
| 32 | Current : 'current'; | ||
| 33 | |||
| 34 | Default : 'default'; | ||
| 35 | |||
| 36 | Extends : 'extends'; | ||
| 37 | |||
| 38 | Unknown : 'unknown'; | ||
| 39 | |||
| 40 | NOT_EQ : 'NOT_EQ'; | ||
| 41 | |||
| 42 | Extern : 'extern'; | ||
| 43 | |||
| 44 | Class : 'class'; | ||
| 45 | |||
| 46 | Count : 'count'; | ||
| 47 | |||
| 48 | Empty : 'empty'; | ||
| 49 | |||
| 50 | Error : 'error'; | ||
| 51 | |||
| 52 | False : 'false'; | ||
| 53 | |||
| 54 | Scope : 'scope'; | ||
| 55 | |||
| 56 | LESS : 'LESS'; | ||
| 57 | |||
| 58 | Else : 'else'; | ||
| 59 | |||
| 60 | Must : 'must'; | ||
| 61 | |||
| 62 | Only : 'only'; | ||
| 63 | |||
| 64 | Prod : 'prod'; | ||
| 65 | |||
| 66 | Real : 'real'; | ||
| 67 | |||
| 68 | Then : 'then'; | ||
| 69 | |||
| 70 | True : 'true'; | ||
| 71 | |||
| 72 | ADD : 'ADD'; | ||
| 73 | |||
| 74 | DIV : 'DIV'; | ||
| 75 | |||
| 76 | MUL : 'MUL'; | ||
| 77 | |||
| 78 | POW : 'POW'; | ||
| 79 | |||
| 80 | SUB : 'SUB'; | ||
| 81 | |||
| 82 | Avg : 'avg'; | ||
| 83 | |||
| 84 | Inf : 'inf'; | ||
| 85 | |||
| 86 | Int : 'int'; | ||
| 87 | |||
| 88 | Max : 'max'; | ||
| 89 | |||
| 90 | May : 'may'; | ||
| 91 | |||
| 92 | Min : 'min'; | ||
| 93 | |||
| 94 | Sum : 'sum'; | ||
| 95 | |||
| 96 | ExclamationMarkEqualsSign : '!='; | ||
| 97 | |||
| 98 | HyphenMinusGreaterThanSign : '->'; | ||
| 99 | |||
| 100 | FullStopFullStop : '..'; | ||
| 101 | |||
| 102 | ColonHyphenMinus : ':-'; | ||
| 103 | |||
| 104 | LessThanSignEqualsSign : '<='; | ||
| 105 | |||
| 106 | EqualsSignEqualsSign : '=='; | ||
| 107 | |||
| 108 | GreaterThanSignEqualsSign : '>='; | ||
| 109 | |||
| 110 | EQ : 'EQ'; | ||
| 111 | |||
| 112 | IN : 'IN'; | ||
| 113 | |||
| 114 | If : 'if'; | ||
| 115 | |||
| 116 | In : 'in'; | ||
| 117 | |||
| 118 | ExclamationMark : '!'; | ||
| 119 | |||
| 120 | LeftParenthesis : '('; | ||
| 121 | |||
| 122 | RightParenthesis : ')'; | ||
| 123 | |||
| 124 | Asterisk : '*'; | ||
| 125 | |||
| 126 | PlusSign : '+'; | ||
| 127 | |||
| 128 | Comma : ','; | ||
| 129 | |||
| 130 | HyphenMinus : '-'; | ||
| 131 | |||
| 132 | FullStop : '.'; | ||
| 133 | |||
| 134 | Solidus : '/'; | ||
| 135 | |||
| 136 | Colon : ':'; | ||
| 137 | |||
| 138 | Semicolon : ';'; | ||
| 139 | |||
| 140 | LessThanSign : '<'; | ||
| 141 | |||
| 142 | EqualsSign : '='; | ||
| 143 | |||
| 144 | GreaterThanSign : '>'; | ||
| 145 | |||
| 146 | LeftSquareBracket : '['; | ||
| 147 | |||
| 148 | RightSquareBracket : ']'; | ||
| 149 | |||
| 150 | CircumflexAccent : '^'; | ||
| 151 | |||
| 152 | LeftCurlyBracket : '{'; | ||
| 153 | |||
| 154 | VerticalLine : '|'; | ||
| 155 | |||
| 156 | RightCurlyBracket : '}'; | ||
| 157 | |||
| 158 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
| 159 | |||
| 160 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
| 161 | |||
| 162 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
| 163 | |||
| 164 | fragment RULE_TRANSITIVE_CLOSURE : ; | ||
| 165 | |||
| 166 | fragment RULE_REFLEXIVE_TRANSITIVE_CLOSURE : ; | ||
| 167 | |||
| 168 | fragment RULE_FULL_STOP : ; | ||
| 169 | |||
| 170 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
| 171 | |||
| 172 | RULE_INT : ('0'..'9')+; | ||
| 173 | |||
| 174 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
| 175 | |||
| 176 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
| 177 | |||
| 178 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java new file mode 100644 index 00000000..b46f86fc --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java | |||
| @@ -0,0 +1,3208 @@ | |||
| 1 | package org.eclipse.viatra.solver.language.parser.antlr.lexer; | ||
| 2 | |||
| 3 | // Hack: Use our own Lexer superclass by means of import. | ||
| 4 | // Currently there is no other way to specify the superclass for the lexer. | ||
| 5 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
| 6 | |||
| 7 | |||
| 8 | import org.antlr.runtime.*; | ||
| 9 | import java.util.Stack; | ||
| 10 | import java.util.List; | ||
| 11 | import java.util.ArrayList; | ||
| 12 | |||
| 13 | @SuppressWarnings("all") | ||
| 14 | public class InternalSolverLanguageLexer extends Lexer { | ||
| 15 | public static final int ADD=33; | ||
| 16 | public static final int True=32; | ||
| 17 | public static final int GREATER_EQ=4; | ||
| 18 | public static final int Count=20; | ||
| 19 | public static final int False=23; | ||
| 20 | public static final int Must=27; | ||
| 21 | public static final int LessThanSign=67; | ||
| 22 | public static final int LeftParenthesis=57; | ||
| 23 | public static final int Unknown=16; | ||
| 24 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80; | ||
| 25 | public static final int FullStopFullStop=47; | ||
| 26 | public static final int Real=30; | ||
| 27 | public static final int Then=31; | ||
| 28 | public static final int Extends=15; | ||
| 29 | public static final int RightSquareBracket=71; | ||
| 30 | public static final int ExclamationMark=56; | ||
| 31 | public static final int Opposite=10; | ||
| 32 | public static final int SUB=37; | ||
| 33 | public static final int GreaterThanSign=69; | ||
| 34 | public static final int NOT_EQ=17; | ||
| 35 | public static final int RULE_ID=82; | ||
| 36 | public static final int MUL=35; | ||
| 37 | public static final int IN=53; | ||
| 38 | public static final int RULE_QUOTED_ID=77; | ||
| 39 | public static final int RightParenthesis=58; | ||
| 40 | public static final int Sum=44; | ||
| 41 | public static final int EQ=52; | ||
| 42 | public static final int GreaterThanSignEqualsSign=51; | ||
| 43 | public static final int Functional=5; | ||
| 44 | public static final int EqualsSignEqualsSign=50; | ||
| 45 | public static final int Avg=38; | ||
| 46 | public static final int Min=43; | ||
| 47 | public static final int VerticalLine=74; | ||
| 48 | public static final int PlusSign=60; | ||
| 49 | public static final int RULE_INT=83; | ||
| 50 | public static final int Contains=7; | ||
| 51 | public static final int RULE_ML_COMMENT=84; | ||
| 52 | public static final int POW=36; | ||
| 53 | public static final int RULE_TRANSITIVE_CLOSURE=79; | ||
| 54 | public static final int Class=19; | ||
| 55 | public static final int LESS=25; | ||
| 56 | public static final int LeftSquareBracket=70; | ||
| 57 | public static final int RULE_FULL_STOP=81; | ||
| 58 | public static final int Current=13; | ||
| 59 | public static final int If=54; | ||
| 60 | public static final int Inf=39; | ||
| 61 | public static final int LESS_EQ=12; | ||
| 62 | public static final int May=42; | ||
| 63 | public static final int Max=41; | ||
| 64 | public static final int In=55; | ||
| 65 | public static final int RULE_STRING=76; | ||
| 66 | public static final int Int=40; | ||
| 67 | public static final int Extern=18; | ||
| 68 | public static final int RULE_SL_COMMENT=78; | ||
| 69 | public static final int Prod=29; | ||
| 70 | public static final int Comma=61; | ||
| 71 | public static final int EqualsSign=68; | ||
| 72 | public static final int Empty=21; | ||
| 73 | public static final int HyphenMinus=62; | ||
| 74 | public static final int Maximize=8; | ||
| 75 | public static final int LessThanSignEqualsSign=49; | ||
| 76 | public static final int Solidus=64; | ||
| 77 | public static final int Colon=65; | ||
| 78 | public static final int RightCurlyBracket=75; | ||
| 79 | public static final int EOF=-1; | ||
| 80 | public static final int Asterisk=59; | ||
| 81 | public static final int FullStop=63; | ||
| 82 | public static final int RULE_WS=85; | ||
| 83 | public static final int Abstract=6; | ||
| 84 | public static final int Minimize=9; | ||
| 85 | public static final int GREATER=11; | ||
| 86 | public static final int LeftCurlyBracket=73; | ||
| 87 | public static final int Error=22; | ||
| 88 | public static final int Only=28; | ||
| 89 | public static final int RULE_ANY_OTHER=86; | ||
| 90 | public static final int Default=14; | ||
| 91 | public static final int ColonHyphenMinus=48; | ||
| 92 | public static final int CircumflexAccent=72; | ||
| 93 | public static final int DIV=34; | ||
| 94 | public static final int Semicolon=66; | ||
| 95 | public static final int Scope=24; | ||
| 96 | public static final int Else=26; | ||
| 97 | public static final int ExclamationMarkEqualsSign=45; | ||
| 98 | public static final int HyphenMinusGreaterThanSign=46; | ||
| 99 | |||
| 100 | // delegates | ||
| 101 | // delegators | ||
| 102 | |||
| 103 | public InternalSolverLanguageLexer() {;} | ||
| 104 | public InternalSolverLanguageLexer(CharStream input) { | ||
| 105 | this(input, new RecognizerSharedState()); | ||
| 106 | } | ||
| 107 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
| 108 | super(input,state); | ||
| 109 | |||
| 110 | } | ||
| 111 | public String getGrammarFileName() { return "InternalSolverLanguageLexer.g"; } | ||
| 112 | |||
| 113 | // $ANTLR start "GREATER_EQ" | ||
| 114 | public final void mGREATER_EQ() throws RecognitionException { | ||
| 115 | try { | ||
| 116 | int _type = GREATER_EQ; | ||
| 117 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 118 | // InternalSolverLanguageLexer.g:14:12: ( 'GREATER_EQ' ) | ||
| 119 | // InternalSolverLanguageLexer.g:14:14: 'GREATER_EQ' | ||
| 120 | { | ||
| 121 | match("GREATER_EQ"); | ||
| 122 | |||
| 123 | |||
| 124 | } | ||
| 125 | |||
| 126 | state.type = _type; | ||
| 127 | state.channel = _channel; | ||
| 128 | } | ||
| 129 | finally { | ||
| 130 | } | ||
| 131 | } | ||
| 132 | // $ANTLR end "GREATER_EQ" | ||
| 133 | |||
| 134 | // $ANTLR start "Functional" | ||
| 135 | public final void mFunctional() throws RecognitionException { | ||
| 136 | try { | ||
| 137 | int _type = Functional; | ||
| 138 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 139 | // InternalSolverLanguageLexer.g:16:12: ( 'functional' ) | ||
| 140 | // InternalSolverLanguageLexer.g:16:14: 'functional' | ||
| 141 | { | ||
| 142 | match("functional"); | ||
| 143 | |||
| 144 | |||
| 145 | } | ||
| 146 | |||
| 147 | state.type = _type; | ||
| 148 | state.channel = _channel; | ||
| 149 | } | ||
| 150 | finally { | ||
| 151 | } | ||
| 152 | } | ||
| 153 | // $ANTLR end "Functional" | ||
| 154 | |||
| 155 | // $ANTLR start "Abstract" | ||
| 156 | public final void mAbstract() throws RecognitionException { | ||
| 157 | try { | ||
| 158 | int _type = Abstract; | ||
| 159 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 160 | // InternalSolverLanguageLexer.g:18:10: ( 'abstract' ) | ||
| 161 | // InternalSolverLanguageLexer.g:18:12: 'abstract' | ||
| 162 | { | ||
| 163 | match("abstract"); | ||
| 164 | |||
| 165 | |||
| 166 | } | ||
| 167 | |||
| 168 | state.type = _type; | ||
| 169 | state.channel = _channel; | ||
| 170 | } | ||
| 171 | finally { | ||
| 172 | } | ||
| 173 | } | ||
| 174 | // $ANTLR end "Abstract" | ||
| 175 | |||
| 176 | // $ANTLR start "Contains" | ||
| 177 | public final void mContains() throws RecognitionException { | ||
| 178 | try { | ||
| 179 | int _type = Contains; | ||
| 180 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 181 | // InternalSolverLanguageLexer.g:20:10: ( 'contains' ) | ||
| 182 | // InternalSolverLanguageLexer.g:20:12: 'contains' | ||
| 183 | { | ||
| 184 | match("contains"); | ||
| 185 | |||
| 186 | |||
| 187 | } | ||
| 188 | |||
| 189 | state.type = _type; | ||
| 190 | state.channel = _channel; | ||
| 191 | } | ||
| 192 | finally { | ||
| 193 | } | ||
| 194 | } | ||
| 195 | // $ANTLR end "Contains" | ||
| 196 | |||
| 197 | // $ANTLR start "Maximize" | ||
| 198 | public final void mMaximize() throws RecognitionException { | ||
| 199 | try { | ||
| 200 | int _type = Maximize; | ||
| 201 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 202 | // InternalSolverLanguageLexer.g:22:10: ( 'maximize' ) | ||
| 203 | // InternalSolverLanguageLexer.g:22:12: 'maximize' | ||
| 204 | { | ||
| 205 | match("maximize"); | ||
| 206 | |||
| 207 | |||
| 208 | } | ||
| 209 | |||
| 210 | state.type = _type; | ||
| 211 | state.channel = _channel; | ||
| 212 | } | ||
| 213 | finally { | ||
| 214 | } | ||
| 215 | } | ||
| 216 | // $ANTLR end "Maximize" | ||
| 217 | |||
| 218 | // $ANTLR start "Minimize" | ||
| 219 | public final void mMinimize() throws RecognitionException { | ||
| 220 | try { | ||
| 221 | int _type = Minimize; | ||
| 222 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 223 | // InternalSolverLanguageLexer.g:24:10: ( 'minimize' ) | ||
| 224 | // InternalSolverLanguageLexer.g:24:12: 'minimize' | ||
| 225 | { | ||
| 226 | match("minimize"); | ||
| 227 | |||
| 228 | |||
| 229 | } | ||
| 230 | |||
| 231 | state.type = _type; | ||
| 232 | state.channel = _channel; | ||
| 233 | } | ||
| 234 | finally { | ||
| 235 | } | ||
| 236 | } | ||
| 237 | // $ANTLR end "Minimize" | ||
| 238 | |||
| 239 | // $ANTLR start "Opposite" | ||
| 240 | public final void mOpposite() throws RecognitionException { | ||
| 241 | try { | ||
| 242 | int _type = Opposite; | ||
| 243 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 244 | // InternalSolverLanguageLexer.g:26:10: ( 'opposite' ) | ||
| 245 | // InternalSolverLanguageLexer.g:26:12: 'opposite' | ||
| 246 | { | ||
| 247 | match("opposite"); | ||
| 248 | |||
| 249 | |||
| 250 | } | ||
| 251 | |||
| 252 | state.type = _type; | ||
| 253 | state.channel = _channel; | ||
| 254 | } | ||
| 255 | finally { | ||
| 256 | } | ||
| 257 | } | ||
| 258 | // $ANTLR end "Opposite" | ||
| 259 | |||
| 260 | // $ANTLR start "GREATER" | ||
| 261 | public final void mGREATER() throws RecognitionException { | ||
| 262 | try { | ||
| 263 | int _type = GREATER; | ||
| 264 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 265 | // InternalSolverLanguageLexer.g:28:9: ( 'GREATER' ) | ||
| 266 | // InternalSolverLanguageLexer.g:28:11: 'GREATER' | ||
| 267 | { | ||
| 268 | match("GREATER"); | ||
| 269 | |||
| 270 | |||
| 271 | } | ||
| 272 | |||
| 273 | state.type = _type; | ||
| 274 | state.channel = _channel; | ||
| 275 | } | ||
| 276 | finally { | ||
| 277 | } | ||
| 278 | } | ||
| 279 | // $ANTLR end "GREATER" | ||
| 280 | |||
| 281 | // $ANTLR start "LESS_EQ" | ||
| 282 | public final void mLESS_EQ() throws RecognitionException { | ||
| 283 | try { | ||
| 284 | int _type = LESS_EQ; | ||
| 285 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 286 | // InternalSolverLanguageLexer.g:30:9: ( 'LESS_EQ' ) | ||
| 287 | // InternalSolverLanguageLexer.g:30:11: 'LESS_EQ' | ||
| 288 | { | ||
| 289 | match("LESS_EQ"); | ||
| 290 | |||
| 291 | |||
| 292 | } | ||
| 293 | |||
| 294 | state.type = _type; | ||
| 295 | state.channel = _channel; | ||
| 296 | } | ||
| 297 | finally { | ||
| 298 | } | ||
| 299 | } | ||
| 300 | // $ANTLR end "LESS_EQ" | ||
| 301 | |||
| 302 | // $ANTLR start "Current" | ||
| 303 | public final void mCurrent() throws RecognitionException { | ||
| 304 | try { | ||
| 305 | int _type = Current; | ||
| 306 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 307 | // InternalSolverLanguageLexer.g:32:9: ( 'current' ) | ||
| 308 | // InternalSolverLanguageLexer.g:32:11: 'current' | ||
| 309 | { | ||
| 310 | match("current"); | ||
| 311 | |||
| 312 | |||
| 313 | } | ||
| 314 | |||
| 315 | state.type = _type; | ||
| 316 | state.channel = _channel; | ||
| 317 | } | ||
| 318 | finally { | ||
| 319 | } | ||
| 320 | } | ||
| 321 | // $ANTLR end "Current" | ||
| 322 | |||
| 323 | // $ANTLR start "Default" | ||
| 324 | public final void mDefault() throws RecognitionException { | ||
| 325 | try { | ||
| 326 | int _type = Default; | ||
| 327 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 328 | // InternalSolverLanguageLexer.g:34:9: ( 'default' ) | ||
| 329 | // InternalSolverLanguageLexer.g:34:11: 'default' | ||
| 330 | { | ||
| 331 | match("default"); | ||
| 332 | |||
| 333 | |||
| 334 | } | ||
| 335 | |||
| 336 | state.type = _type; | ||
| 337 | state.channel = _channel; | ||
| 338 | } | ||
| 339 | finally { | ||
| 340 | } | ||
| 341 | } | ||
| 342 | // $ANTLR end "Default" | ||
| 343 | |||
| 344 | // $ANTLR start "Extends" | ||
| 345 | public final void mExtends() throws RecognitionException { | ||
| 346 | try { | ||
| 347 | int _type = Extends; | ||
| 348 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 349 | // InternalSolverLanguageLexer.g:36:9: ( 'extends' ) | ||
| 350 | // InternalSolverLanguageLexer.g:36:11: 'extends' | ||
| 351 | { | ||
| 352 | match("extends"); | ||
| 353 | |||
| 354 | |||
| 355 | } | ||
| 356 | |||
| 357 | state.type = _type; | ||
| 358 | state.channel = _channel; | ||
| 359 | } | ||
| 360 | finally { | ||
| 361 | } | ||
| 362 | } | ||
| 363 | // $ANTLR end "Extends" | ||
| 364 | |||
| 365 | // $ANTLR start "Unknown" | ||
| 366 | public final void mUnknown() throws RecognitionException { | ||
| 367 | try { | ||
| 368 | int _type = Unknown; | ||
| 369 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 370 | // InternalSolverLanguageLexer.g:38:9: ( 'unknown' ) | ||
| 371 | // InternalSolverLanguageLexer.g:38:11: 'unknown' | ||
| 372 | { | ||
| 373 | match("unknown"); | ||
| 374 | |||
| 375 | |||
| 376 | } | ||
| 377 | |||
| 378 | state.type = _type; | ||
| 379 | state.channel = _channel; | ||
| 380 | } | ||
| 381 | finally { | ||
| 382 | } | ||
| 383 | } | ||
| 384 | // $ANTLR end "Unknown" | ||
| 385 | |||
| 386 | // $ANTLR start "NOT_EQ" | ||
| 387 | public final void mNOT_EQ() throws RecognitionException { | ||
| 388 | try { | ||
| 389 | int _type = NOT_EQ; | ||
| 390 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 391 | // InternalSolverLanguageLexer.g:40:8: ( 'NOT_EQ' ) | ||
| 392 | // InternalSolverLanguageLexer.g:40:10: 'NOT_EQ' | ||
| 393 | { | ||
| 394 | match("NOT_EQ"); | ||
| 395 | |||
| 396 | |||
| 397 | } | ||
| 398 | |||
| 399 | state.type = _type; | ||
| 400 | state.channel = _channel; | ||
| 401 | } | ||
| 402 | finally { | ||
| 403 | } | ||
| 404 | } | ||
| 405 | // $ANTLR end "NOT_EQ" | ||
| 406 | |||
| 407 | // $ANTLR start "Extern" | ||
| 408 | public final void mExtern() throws RecognitionException { | ||
| 409 | try { | ||
| 410 | int _type = Extern; | ||
| 411 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 412 | // InternalSolverLanguageLexer.g:42:8: ( 'extern' ) | ||
| 413 | // InternalSolverLanguageLexer.g:42:10: 'extern' | ||
| 414 | { | ||
| 415 | match("extern"); | ||
| 416 | |||
| 417 | |||
| 418 | } | ||
| 419 | |||
| 420 | state.type = _type; | ||
| 421 | state.channel = _channel; | ||
| 422 | } | ||
| 423 | finally { | ||
| 424 | } | ||
| 425 | } | ||
| 426 | // $ANTLR end "Extern" | ||
| 427 | |||
| 428 | // $ANTLR start "Class" | ||
| 429 | public final void mClass() throws RecognitionException { | ||
| 430 | try { | ||
| 431 | int _type = Class; | ||
| 432 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 433 | // InternalSolverLanguageLexer.g:44:7: ( 'class' ) | ||
| 434 | // InternalSolverLanguageLexer.g:44:9: 'class' | ||
| 435 | { | ||
| 436 | match("class"); | ||
| 437 | |||
| 438 | |||
| 439 | } | ||
| 440 | |||
| 441 | state.type = _type; | ||
| 442 | state.channel = _channel; | ||
| 443 | } | ||
| 444 | finally { | ||
| 445 | } | ||
| 446 | } | ||
| 447 | // $ANTLR end "Class" | ||
| 448 | |||
| 449 | // $ANTLR start "Count" | ||
| 450 | public final void mCount() throws RecognitionException { | ||
| 451 | try { | ||
| 452 | int _type = Count; | ||
| 453 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 454 | // InternalSolverLanguageLexer.g:46:7: ( 'count' ) | ||
| 455 | // InternalSolverLanguageLexer.g:46:9: 'count' | ||
| 456 | { | ||
| 457 | match("count"); | ||
| 458 | |||
| 459 | |||
| 460 | } | ||
| 461 | |||
| 462 | state.type = _type; | ||
| 463 | state.channel = _channel; | ||
| 464 | } | ||
| 465 | finally { | ||
| 466 | } | ||
| 467 | } | ||
| 468 | // $ANTLR end "Count" | ||
| 469 | |||
| 470 | // $ANTLR start "Empty" | ||
| 471 | public final void mEmpty() throws RecognitionException { | ||
| 472 | try { | ||
| 473 | int _type = Empty; | ||
| 474 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 475 | // InternalSolverLanguageLexer.g:48:7: ( 'empty' ) | ||
| 476 | // InternalSolverLanguageLexer.g:48:9: 'empty' | ||
| 477 | { | ||
| 478 | match("empty"); | ||
| 479 | |||
| 480 | |||
| 481 | } | ||
| 482 | |||
| 483 | state.type = _type; | ||
| 484 | state.channel = _channel; | ||
| 485 | } | ||
| 486 | finally { | ||
| 487 | } | ||
| 488 | } | ||
| 489 | // $ANTLR end "Empty" | ||
| 490 | |||
| 491 | // $ANTLR start "Error" | ||
| 492 | public final void mError() throws RecognitionException { | ||
| 493 | try { | ||
| 494 | int _type = Error; | ||
| 495 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 496 | // InternalSolverLanguageLexer.g:50:7: ( 'error' ) | ||
| 497 | // InternalSolverLanguageLexer.g:50:9: 'error' | ||
| 498 | { | ||
| 499 | match("error"); | ||
| 500 | |||
| 501 | |||
| 502 | } | ||
| 503 | |||
| 504 | state.type = _type; | ||
| 505 | state.channel = _channel; | ||
| 506 | } | ||
| 507 | finally { | ||
| 508 | } | ||
| 509 | } | ||
| 510 | // $ANTLR end "Error" | ||
| 511 | |||
| 512 | // $ANTLR start "False" | ||
| 513 | public final void mFalse() throws RecognitionException { | ||
| 514 | try { | ||
| 515 | int _type = False; | ||
| 516 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 517 | // InternalSolverLanguageLexer.g:52:7: ( 'false' ) | ||
| 518 | // InternalSolverLanguageLexer.g:52:9: 'false' | ||
| 519 | { | ||
| 520 | match("false"); | ||
| 521 | |||
| 522 | |||
| 523 | } | ||
| 524 | |||
| 525 | state.type = _type; | ||
| 526 | state.channel = _channel; | ||
| 527 | } | ||
| 528 | finally { | ||
| 529 | } | ||
| 530 | } | ||
| 531 | // $ANTLR end "False" | ||
| 532 | |||
| 533 | // $ANTLR start "Scope" | ||
| 534 | public final void mScope() throws RecognitionException { | ||
| 535 | try { | ||
| 536 | int _type = Scope; | ||
| 537 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 538 | // InternalSolverLanguageLexer.g:54:7: ( 'scope' ) | ||
| 539 | // InternalSolverLanguageLexer.g:54:9: 'scope' | ||
| 540 | { | ||
| 541 | match("scope"); | ||
| 542 | |||
| 543 | |||
| 544 | } | ||
| 545 | |||
| 546 | state.type = _type; | ||
| 547 | state.channel = _channel; | ||
| 548 | } | ||
| 549 | finally { | ||
| 550 | } | ||
| 551 | } | ||
| 552 | // $ANTLR end "Scope" | ||
| 553 | |||
| 554 | // $ANTLR start "LESS" | ||
| 555 | public final void mLESS() throws RecognitionException { | ||
| 556 | try { | ||
| 557 | int _type = LESS; | ||
| 558 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 559 | // InternalSolverLanguageLexer.g:56:6: ( 'LESS' ) | ||
| 560 | // InternalSolverLanguageLexer.g:56:8: 'LESS' | ||
| 561 | { | ||
| 562 | match("LESS"); | ||
| 563 | |||
| 564 | |||
| 565 | } | ||
| 566 | |||
| 567 | state.type = _type; | ||
| 568 | state.channel = _channel; | ||
| 569 | } | ||
| 570 | finally { | ||
| 571 | } | ||
| 572 | } | ||
| 573 | // $ANTLR end "LESS" | ||
| 574 | |||
| 575 | // $ANTLR start "Else" | ||
| 576 | public final void mElse() throws RecognitionException { | ||
| 577 | try { | ||
| 578 | int _type = Else; | ||
| 579 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 580 | // InternalSolverLanguageLexer.g:58:6: ( 'else' ) | ||
| 581 | // InternalSolverLanguageLexer.g:58:8: 'else' | ||
| 582 | { | ||
| 583 | match("else"); | ||
| 584 | |||
| 585 | |||
| 586 | } | ||
| 587 | |||
| 588 | state.type = _type; | ||
| 589 | state.channel = _channel; | ||
| 590 | } | ||
| 591 | finally { | ||
| 592 | } | ||
| 593 | } | ||
| 594 | // $ANTLR end "Else" | ||
| 595 | |||
| 596 | // $ANTLR start "Must" | ||
| 597 | public final void mMust() throws RecognitionException { | ||
| 598 | try { | ||
| 599 | int _type = Must; | ||
| 600 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 601 | // InternalSolverLanguageLexer.g:60:6: ( 'must' ) | ||
| 602 | // InternalSolverLanguageLexer.g:60:8: 'must' | ||
| 603 | { | ||
| 604 | match("must"); | ||
| 605 | |||
| 606 | |||
| 607 | } | ||
| 608 | |||
| 609 | state.type = _type; | ||
| 610 | state.channel = _channel; | ||
| 611 | } | ||
| 612 | finally { | ||
| 613 | } | ||
| 614 | } | ||
| 615 | // $ANTLR end "Must" | ||
| 616 | |||
| 617 | // $ANTLR start "Only" | ||
| 618 | public final void mOnly() throws RecognitionException { | ||
| 619 | try { | ||
| 620 | int _type = Only; | ||
| 621 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 622 | // InternalSolverLanguageLexer.g:62:6: ( 'only' ) | ||
| 623 | // InternalSolverLanguageLexer.g:62:8: 'only' | ||
| 624 | { | ||
| 625 | match("only"); | ||
| 626 | |||
| 627 | |||
| 628 | } | ||
| 629 | |||
| 630 | state.type = _type; | ||
| 631 | state.channel = _channel; | ||
| 632 | } | ||
| 633 | finally { | ||
| 634 | } | ||
| 635 | } | ||
| 636 | // $ANTLR end "Only" | ||
| 637 | |||
| 638 | // $ANTLR start "Prod" | ||
| 639 | public final void mProd() throws RecognitionException { | ||
| 640 | try { | ||
| 641 | int _type = Prod; | ||
| 642 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 643 | // InternalSolverLanguageLexer.g:64:6: ( 'prod' ) | ||
| 644 | // InternalSolverLanguageLexer.g:64:8: 'prod' | ||
| 645 | { | ||
| 646 | match("prod"); | ||
| 647 | |||
| 648 | |||
| 649 | } | ||
| 650 | |||
| 651 | state.type = _type; | ||
| 652 | state.channel = _channel; | ||
| 653 | } | ||
| 654 | finally { | ||
| 655 | } | ||
| 656 | } | ||
| 657 | // $ANTLR end "Prod" | ||
| 658 | |||
| 659 | // $ANTLR start "Real" | ||
| 660 | public final void mReal() throws RecognitionException { | ||
| 661 | try { | ||
| 662 | int _type = Real; | ||
| 663 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 664 | // InternalSolverLanguageLexer.g:66:6: ( 'real' ) | ||
| 665 | // InternalSolverLanguageLexer.g:66:8: 'real' | ||
| 666 | { | ||
| 667 | match("real"); | ||
| 668 | |||
| 669 | |||
| 670 | } | ||
| 671 | |||
| 672 | state.type = _type; | ||
| 673 | state.channel = _channel; | ||
| 674 | } | ||
| 675 | finally { | ||
| 676 | } | ||
| 677 | } | ||
| 678 | // $ANTLR end "Real" | ||
| 679 | |||
| 680 | // $ANTLR start "Then" | ||
| 681 | public final void mThen() throws RecognitionException { | ||
| 682 | try { | ||
| 683 | int _type = Then; | ||
| 684 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 685 | // InternalSolverLanguageLexer.g:68:6: ( 'then' ) | ||
| 686 | // InternalSolverLanguageLexer.g:68:8: 'then' | ||
| 687 | { | ||
| 688 | match("then"); | ||
| 689 | |||
| 690 | |||
| 691 | } | ||
| 692 | |||
| 693 | state.type = _type; | ||
| 694 | state.channel = _channel; | ||
| 695 | } | ||
| 696 | finally { | ||
| 697 | } | ||
| 698 | } | ||
| 699 | // $ANTLR end "Then" | ||
| 700 | |||
| 701 | // $ANTLR start "True" | ||
| 702 | public final void mTrue() throws RecognitionException { | ||
| 703 | try { | ||
| 704 | int _type = True; | ||
| 705 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 706 | // InternalSolverLanguageLexer.g:70:6: ( 'true' ) | ||
| 707 | // InternalSolverLanguageLexer.g:70:8: 'true' | ||
| 708 | { | ||
| 709 | match("true"); | ||
| 710 | |||
| 711 | |||
| 712 | } | ||
| 713 | |||
| 714 | state.type = _type; | ||
| 715 | state.channel = _channel; | ||
| 716 | } | ||
| 717 | finally { | ||
| 718 | } | ||
| 719 | } | ||
| 720 | // $ANTLR end "True" | ||
| 721 | |||
| 722 | // $ANTLR start "ADD" | ||
| 723 | public final void mADD() throws RecognitionException { | ||
| 724 | try { | ||
| 725 | int _type = ADD; | ||
| 726 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 727 | // InternalSolverLanguageLexer.g:72:5: ( 'ADD' ) | ||
| 728 | // InternalSolverLanguageLexer.g:72:7: 'ADD' | ||
| 729 | { | ||
| 730 | match("ADD"); | ||
| 731 | |||
| 732 | |||
| 733 | } | ||
| 734 | |||
| 735 | state.type = _type; | ||
| 736 | state.channel = _channel; | ||
| 737 | } | ||
| 738 | finally { | ||
| 739 | } | ||
| 740 | } | ||
| 741 | // $ANTLR end "ADD" | ||
| 742 | |||
| 743 | // $ANTLR start "DIV" | ||
| 744 | public final void mDIV() throws RecognitionException { | ||
| 745 | try { | ||
| 746 | int _type = DIV; | ||
| 747 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 748 | // InternalSolverLanguageLexer.g:74:5: ( 'DIV' ) | ||
| 749 | // InternalSolverLanguageLexer.g:74:7: 'DIV' | ||
| 750 | { | ||
| 751 | match("DIV"); | ||
| 752 | |||
| 753 | |||
| 754 | } | ||
| 755 | |||
| 756 | state.type = _type; | ||
| 757 | state.channel = _channel; | ||
| 758 | } | ||
| 759 | finally { | ||
| 760 | } | ||
| 761 | } | ||
| 762 | // $ANTLR end "DIV" | ||
| 763 | |||
| 764 | // $ANTLR start "MUL" | ||
| 765 | public final void mMUL() throws RecognitionException { | ||
| 766 | try { | ||
| 767 | int _type = MUL; | ||
| 768 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 769 | // InternalSolverLanguageLexer.g:76:5: ( 'MUL' ) | ||
| 770 | // InternalSolverLanguageLexer.g:76:7: 'MUL' | ||
| 771 | { | ||
| 772 | match("MUL"); | ||
| 773 | |||
| 774 | |||
| 775 | } | ||
| 776 | |||
| 777 | state.type = _type; | ||
| 778 | state.channel = _channel; | ||
| 779 | } | ||
| 780 | finally { | ||
| 781 | } | ||
| 782 | } | ||
| 783 | // $ANTLR end "MUL" | ||
| 784 | |||
| 785 | // $ANTLR start "POW" | ||
| 786 | public final void mPOW() throws RecognitionException { | ||
| 787 | try { | ||
| 788 | int _type = POW; | ||
| 789 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 790 | // InternalSolverLanguageLexer.g:78:5: ( 'POW' ) | ||
| 791 | // InternalSolverLanguageLexer.g:78:7: 'POW' | ||
| 792 | { | ||
| 793 | match("POW"); | ||
| 794 | |||
| 795 | |||
| 796 | } | ||
| 797 | |||
| 798 | state.type = _type; | ||
| 799 | state.channel = _channel; | ||
| 800 | } | ||
| 801 | finally { | ||
| 802 | } | ||
| 803 | } | ||
| 804 | // $ANTLR end "POW" | ||
| 805 | |||
| 806 | // $ANTLR start "SUB" | ||
| 807 | public final void mSUB() throws RecognitionException { | ||
| 808 | try { | ||
| 809 | int _type = SUB; | ||
| 810 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 811 | // InternalSolverLanguageLexer.g:80:5: ( 'SUB' ) | ||
| 812 | // InternalSolverLanguageLexer.g:80:7: 'SUB' | ||
| 813 | { | ||
| 814 | match("SUB"); | ||
| 815 | |||
| 816 | |||
| 817 | } | ||
| 818 | |||
| 819 | state.type = _type; | ||
| 820 | state.channel = _channel; | ||
| 821 | } | ||
| 822 | finally { | ||
| 823 | } | ||
| 824 | } | ||
| 825 | // $ANTLR end "SUB" | ||
| 826 | |||
| 827 | // $ANTLR start "Avg" | ||
| 828 | public final void mAvg() throws RecognitionException { | ||
| 829 | try { | ||
| 830 | int _type = Avg; | ||
| 831 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 832 | // InternalSolverLanguageLexer.g:82:5: ( 'avg' ) | ||
| 833 | // InternalSolverLanguageLexer.g:82:7: 'avg' | ||
| 834 | { | ||
| 835 | match("avg"); | ||
| 836 | |||
| 837 | |||
| 838 | } | ||
| 839 | |||
| 840 | state.type = _type; | ||
| 841 | state.channel = _channel; | ||
| 842 | } | ||
| 843 | finally { | ||
| 844 | } | ||
| 845 | } | ||
| 846 | // $ANTLR end "Avg" | ||
| 847 | |||
| 848 | // $ANTLR start "Inf" | ||
| 849 | public final void mInf() throws RecognitionException { | ||
| 850 | try { | ||
| 851 | int _type = Inf; | ||
| 852 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 853 | // InternalSolverLanguageLexer.g:84:5: ( 'inf' ) | ||
| 854 | // InternalSolverLanguageLexer.g:84:7: 'inf' | ||
| 855 | { | ||
| 856 | match("inf"); | ||
| 857 | |||
| 858 | |||
| 859 | } | ||
| 860 | |||
| 861 | state.type = _type; | ||
| 862 | state.channel = _channel; | ||
| 863 | } | ||
| 864 | finally { | ||
| 865 | } | ||
| 866 | } | ||
| 867 | // $ANTLR end "Inf" | ||
| 868 | |||
| 869 | // $ANTLR start "Int" | ||
| 870 | public final void mInt() throws RecognitionException { | ||
| 871 | try { | ||
| 872 | int _type = Int; | ||
| 873 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 874 | // InternalSolverLanguageLexer.g:86:5: ( 'int' ) | ||
| 875 | // InternalSolverLanguageLexer.g:86:7: 'int' | ||
| 876 | { | ||
| 877 | match("int"); | ||
| 878 | |||
| 879 | |||
| 880 | } | ||
| 881 | |||
| 882 | state.type = _type; | ||
| 883 | state.channel = _channel; | ||
| 884 | } | ||
| 885 | finally { | ||
| 886 | } | ||
| 887 | } | ||
| 888 | // $ANTLR end "Int" | ||
| 889 | |||
| 890 | // $ANTLR start "Max" | ||
| 891 | public final void mMax() throws RecognitionException { | ||
| 892 | try { | ||
| 893 | int _type = Max; | ||
| 894 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 895 | // InternalSolverLanguageLexer.g:88:5: ( 'max' ) | ||
| 896 | // InternalSolverLanguageLexer.g:88:7: 'max' | ||
| 897 | { | ||
| 898 | match("max"); | ||
| 899 | |||
| 900 | |||
| 901 | } | ||
| 902 | |||
| 903 | state.type = _type; | ||
| 904 | state.channel = _channel; | ||
| 905 | } | ||
| 906 | finally { | ||
| 907 | } | ||
| 908 | } | ||
| 909 | // $ANTLR end "Max" | ||
| 910 | |||
| 911 | // $ANTLR start "May" | ||
| 912 | public final void mMay() throws RecognitionException { | ||
| 913 | try { | ||
| 914 | int _type = May; | ||
| 915 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 916 | // InternalSolverLanguageLexer.g:90:5: ( 'may' ) | ||
| 917 | // InternalSolverLanguageLexer.g:90:7: 'may' | ||
| 918 | { | ||
| 919 | match("may"); | ||
| 920 | |||
| 921 | |||
| 922 | } | ||
| 923 | |||
| 924 | state.type = _type; | ||
| 925 | state.channel = _channel; | ||
| 926 | } | ||
| 927 | finally { | ||
| 928 | } | ||
| 929 | } | ||
| 930 | // $ANTLR end "May" | ||
| 931 | |||
| 932 | // $ANTLR start "Min" | ||
| 933 | public final void mMin() throws RecognitionException { | ||
| 934 | try { | ||
| 935 | int _type = Min; | ||
| 936 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 937 | // InternalSolverLanguageLexer.g:92:5: ( 'min' ) | ||
| 938 | // InternalSolverLanguageLexer.g:92:7: 'min' | ||
| 939 | { | ||
| 940 | match("min"); | ||
| 941 | |||
| 942 | |||
| 943 | } | ||
| 944 | |||
| 945 | state.type = _type; | ||
| 946 | state.channel = _channel; | ||
| 947 | } | ||
| 948 | finally { | ||
| 949 | } | ||
| 950 | } | ||
| 951 | // $ANTLR end "Min" | ||
| 952 | |||
| 953 | // $ANTLR start "Sum" | ||
| 954 | public final void mSum() throws RecognitionException { | ||
| 955 | try { | ||
| 956 | int _type = Sum; | ||
| 957 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 958 | // InternalSolverLanguageLexer.g:94:5: ( 'sum' ) | ||
| 959 | // InternalSolverLanguageLexer.g:94:7: 'sum' | ||
| 960 | { | ||
| 961 | match("sum"); | ||
| 962 | |||
| 963 | |||
| 964 | } | ||
| 965 | |||
| 966 | state.type = _type; | ||
| 967 | state.channel = _channel; | ||
| 968 | } | ||
| 969 | finally { | ||
| 970 | } | ||
| 971 | } | ||
| 972 | // $ANTLR end "Sum" | ||
| 973 | |||
| 974 | // $ANTLR start "ExclamationMarkEqualsSign" | ||
| 975 | public final void mExclamationMarkEqualsSign() throws RecognitionException { | ||
| 976 | try { | ||
| 977 | int _type = ExclamationMarkEqualsSign; | ||
| 978 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 979 | // InternalSolverLanguageLexer.g:96:27: ( '!=' ) | ||
| 980 | // InternalSolverLanguageLexer.g:96:29: '!=' | ||
| 981 | { | ||
| 982 | match("!="); | ||
| 983 | |||
| 984 | |||
| 985 | } | ||
| 986 | |||
| 987 | state.type = _type; | ||
| 988 | state.channel = _channel; | ||
| 989 | } | ||
| 990 | finally { | ||
| 991 | } | ||
| 992 | } | ||
| 993 | // $ANTLR end "ExclamationMarkEqualsSign" | ||
| 994 | |||
| 995 | // $ANTLR start "HyphenMinusGreaterThanSign" | ||
| 996 | public final void mHyphenMinusGreaterThanSign() throws RecognitionException { | ||
| 997 | try { | ||
| 998 | int _type = HyphenMinusGreaterThanSign; | ||
| 999 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1000 | // InternalSolverLanguageLexer.g:98:28: ( '->' ) | ||
| 1001 | // InternalSolverLanguageLexer.g:98:30: '->' | ||
| 1002 | { | ||
| 1003 | match("->"); | ||
| 1004 | |||
| 1005 | |||
| 1006 | } | ||
| 1007 | |||
| 1008 | state.type = _type; | ||
| 1009 | state.channel = _channel; | ||
| 1010 | } | ||
| 1011 | finally { | ||
| 1012 | } | ||
| 1013 | } | ||
| 1014 | // $ANTLR end "HyphenMinusGreaterThanSign" | ||
| 1015 | |||
| 1016 | // $ANTLR start "FullStopFullStop" | ||
| 1017 | public final void mFullStopFullStop() throws RecognitionException { | ||
| 1018 | try { | ||
| 1019 | int _type = FullStopFullStop; | ||
| 1020 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1021 | // InternalSolverLanguageLexer.g:100:18: ( '..' ) | ||
| 1022 | // InternalSolverLanguageLexer.g:100:20: '..' | ||
| 1023 | { | ||
| 1024 | match(".."); | ||
| 1025 | |||
| 1026 | |||
| 1027 | } | ||
| 1028 | |||
| 1029 | state.type = _type; | ||
| 1030 | state.channel = _channel; | ||
| 1031 | } | ||
| 1032 | finally { | ||
| 1033 | } | ||
| 1034 | } | ||
| 1035 | // $ANTLR end "FullStopFullStop" | ||
| 1036 | |||
| 1037 | // $ANTLR start "ColonHyphenMinus" | ||
| 1038 | public final void mColonHyphenMinus() throws RecognitionException { | ||
| 1039 | try { | ||
| 1040 | int _type = ColonHyphenMinus; | ||
| 1041 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1042 | // InternalSolverLanguageLexer.g:102:18: ( ':-' ) | ||
| 1043 | // InternalSolverLanguageLexer.g:102:20: ':-' | ||
| 1044 | { | ||
| 1045 | match(":-"); | ||
| 1046 | |||
| 1047 | |||
| 1048 | } | ||
| 1049 | |||
| 1050 | state.type = _type; | ||
| 1051 | state.channel = _channel; | ||
| 1052 | } | ||
| 1053 | finally { | ||
| 1054 | } | ||
| 1055 | } | ||
| 1056 | // $ANTLR end "ColonHyphenMinus" | ||
| 1057 | |||
| 1058 | // $ANTLR start "LessThanSignEqualsSign" | ||
| 1059 | public final void mLessThanSignEqualsSign() throws RecognitionException { | ||
| 1060 | try { | ||
| 1061 | int _type = LessThanSignEqualsSign; | ||
| 1062 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1063 | // InternalSolverLanguageLexer.g:104:24: ( '<=' ) | ||
| 1064 | // InternalSolverLanguageLexer.g:104:26: '<=' | ||
| 1065 | { | ||
| 1066 | match("<="); | ||
| 1067 | |||
| 1068 | |||
| 1069 | } | ||
| 1070 | |||
| 1071 | state.type = _type; | ||
| 1072 | state.channel = _channel; | ||
| 1073 | } | ||
| 1074 | finally { | ||
| 1075 | } | ||
| 1076 | } | ||
| 1077 | // $ANTLR end "LessThanSignEqualsSign" | ||
| 1078 | |||
| 1079 | // $ANTLR start "EqualsSignEqualsSign" | ||
| 1080 | public final void mEqualsSignEqualsSign() throws RecognitionException { | ||
| 1081 | try { | ||
| 1082 | int _type = EqualsSignEqualsSign; | ||
| 1083 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1084 | // InternalSolverLanguageLexer.g:106:22: ( '==' ) | ||
| 1085 | // InternalSolverLanguageLexer.g:106:24: '==' | ||
| 1086 | { | ||
| 1087 | match("=="); | ||
| 1088 | |||
| 1089 | |||
| 1090 | } | ||
| 1091 | |||
| 1092 | state.type = _type; | ||
| 1093 | state.channel = _channel; | ||
| 1094 | } | ||
| 1095 | finally { | ||
| 1096 | } | ||
| 1097 | } | ||
| 1098 | // $ANTLR end "EqualsSignEqualsSign" | ||
| 1099 | |||
| 1100 | // $ANTLR start "GreaterThanSignEqualsSign" | ||
| 1101 | public final void mGreaterThanSignEqualsSign() throws RecognitionException { | ||
| 1102 | try { | ||
| 1103 | int _type = GreaterThanSignEqualsSign; | ||
| 1104 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1105 | // InternalSolverLanguageLexer.g:108:27: ( '>=' ) | ||
| 1106 | // InternalSolverLanguageLexer.g:108:29: '>=' | ||
| 1107 | { | ||
| 1108 | match(">="); | ||
| 1109 | |||
| 1110 | |||
| 1111 | } | ||
| 1112 | |||
| 1113 | state.type = _type; | ||
| 1114 | state.channel = _channel; | ||
| 1115 | } | ||
| 1116 | finally { | ||
| 1117 | } | ||
| 1118 | } | ||
| 1119 | // $ANTLR end "GreaterThanSignEqualsSign" | ||
| 1120 | |||
| 1121 | // $ANTLR start "EQ" | ||
| 1122 | public final void mEQ() throws RecognitionException { | ||
| 1123 | try { | ||
| 1124 | int _type = EQ; | ||
| 1125 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1126 | // InternalSolverLanguageLexer.g:110:4: ( 'EQ' ) | ||
| 1127 | // InternalSolverLanguageLexer.g:110:6: 'EQ' | ||
| 1128 | { | ||
| 1129 | match("EQ"); | ||
| 1130 | |||
| 1131 | |||
| 1132 | } | ||
| 1133 | |||
| 1134 | state.type = _type; | ||
| 1135 | state.channel = _channel; | ||
| 1136 | } | ||
| 1137 | finally { | ||
| 1138 | } | ||
| 1139 | } | ||
| 1140 | // $ANTLR end "EQ" | ||
| 1141 | |||
| 1142 | // $ANTLR start "IN" | ||
| 1143 | public final void mIN() throws RecognitionException { | ||
| 1144 | try { | ||
| 1145 | int _type = IN; | ||
| 1146 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1147 | // InternalSolverLanguageLexer.g:112:4: ( 'IN' ) | ||
| 1148 | // InternalSolverLanguageLexer.g:112:6: 'IN' | ||
| 1149 | { | ||
| 1150 | match("IN"); | ||
| 1151 | |||
| 1152 | |||
| 1153 | } | ||
| 1154 | |||
| 1155 | state.type = _type; | ||
| 1156 | state.channel = _channel; | ||
| 1157 | } | ||
| 1158 | finally { | ||
| 1159 | } | ||
| 1160 | } | ||
| 1161 | // $ANTLR end "IN" | ||
| 1162 | |||
| 1163 | // $ANTLR start "If" | ||
| 1164 | public final void mIf() throws RecognitionException { | ||
| 1165 | try { | ||
| 1166 | int _type = If; | ||
| 1167 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1168 | // InternalSolverLanguageLexer.g:114:4: ( 'if' ) | ||
| 1169 | // InternalSolverLanguageLexer.g:114:6: 'if' | ||
| 1170 | { | ||
| 1171 | match("if"); | ||
| 1172 | |||
| 1173 | |||
| 1174 | } | ||
| 1175 | |||
| 1176 | state.type = _type; | ||
| 1177 | state.channel = _channel; | ||
| 1178 | } | ||
| 1179 | finally { | ||
| 1180 | } | ||
| 1181 | } | ||
| 1182 | // $ANTLR end "If" | ||
| 1183 | |||
| 1184 | // $ANTLR start "In" | ||
| 1185 | public final void mIn() throws RecognitionException { | ||
| 1186 | try { | ||
| 1187 | int _type = In; | ||
| 1188 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1189 | // InternalSolverLanguageLexer.g:116:4: ( 'in' ) | ||
| 1190 | // InternalSolverLanguageLexer.g:116:6: 'in' | ||
| 1191 | { | ||
| 1192 | match("in"); | ||
| 1193 | |||
| 1194 | |||
| 1195 | } | ||
| 1196 | |||
| 1197 | state.type = _type; | ||
| 1198 | state.channel = _channel; | ||
| 1199 | } | ||
| 1200 | finally { | ||
| 1201 | } | ||
| 1202 | } | ||
| 1203 | // $ANTLR end "In" | ||
| 1204 | |||
| 1205 | // $ANTLR start "ExclamationMark" | ||
| 1206 | public final void mExclamationMark() throws RecognitionException { | ||
| 1207 | try { | ||
| 1208 | int _type = ExclamationMark; | ||
| 1209 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1210 | // InternalSolverLanguageLexer.g:118:17: ( '!' ) | ||
| 1211 | // InternalSolverLanguageLexer.g:118:19: '!' | ||
| 1212 | { | ||
| 1213 | match('!'); | ||
| 1214 | |||
| 1215 | } | ||
| 1216 | |||
| 1217 | state.type = _type; | ||
| 1218 | state.channel = _channel; | ||
| 1219 | } | ||
| 1220 | finally { | ||
| 1221 | } | ||
| 1222 | } | ||
| 1223 | // $ANTLR end "ExclamationMark" | ||
| 1224 | |||
| 1225 | // $ANTLR start "LeftParenthesis" | ||
| 1226 | public final void mLeftParenthesis() throws RecognitionException { | ||
| 1227 | try { | ||
| 1228 | int _type = LeftParenthesis; | ||
| 1229 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1230 | // InternalSolverLanguageLexer.g:120:17: ( '(' ) | ||
| 1231 | // InternalSolverLanguageLexer.g:120:19: '(' | ||
| 1232 | { | ||
| 1233 | match('('); | ||
| 1234 | |||
| 1235 | } | ||
| 1236 | |||
| 1237 | state.type = _type; | ||
| 1238 | state.channel = _channel; | ||
| 1239 | } | ||
| 1240 | finally { | ||
| 1241 | } | ||
| 1242 | } | ||
| 1243 | // $ANTLR end "LeftParenthesis" | ||
| 1244 | |||
| 1245 | // $ANTLR start "RightParenthesis" | ||
| 1246 | public final void mRightParenthesis() throws RecognitionException { | ||
| 1247 | try { | ||
| 1248 | int _type = RightParenthesis; | ||
| 1249 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1250 | // InternalSolverLanguageLexer.g:122:18: ( ')' ) | ||
| 1251 | // InternalSolverLanguageLexer.g:122:20: ')' | ||
| 1252 | { | ||
| 1253 | match(')'); | ||
| 1254 | |||
| 1255 | } | ||
| 1256 | |||
| 1257 | state.type = _type; | ||
| 1258 | state.channel = _channel; | ||
| 1259 | } | ||
| 1260 | finally { | ||
| 1261 | } | ||
| 1262 | } | ||
| 1263 | // $ANTLR end "RightParenthesis" | ||
| 1264 | |||
| 1265 | // $ANTLR start "Asterisk" | ||
| 1266 | public final void mAsterisk() throws RecognitionException { | ||
| 1267 | try { | ||
| 1268 | int _type = Asterisk; | ||
| 1269 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1270 | // InternalSolverLanguageLexer.g:124:10: ( '*' ) | ||
| 1271 | // InternalSolverLanguageLexer.g:124:12: '*' | ||
| 1272 | { | ||
| 1273 | match('*'); | ||
| 1274 | |||
| 1275 | } | ||
| 1276 | |||
| 1277 | state.type = _type; | ||
| 1278 | state.channel = _channel; | ||
| 1279 | } | ||
| 1280 | finally { | ||
| 1281 | } | ||
| 1282 | } | ||
| 1283 | // $ANTLR end "Asterisk" | ||
| 1284 | |||
| 1285 | // $ANTLR start "PlusSign" | ||
| 1286 | public final void mPlusSign() throws RecognitionException { | ||
| 1287 | try { | ||
| 1288 | int _type = PlusSign; | ||
| 1289 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1290 | // InternalSolverLanguageLexer.g:126:10: ( '+' ) | ||
| 1291 | // InternalSolverLanguageLexer.g:126:12: '+' | ||
| 1292 | { | ||
| 1293 | match('+'); | ||
| 1294 | |||
| 1295 | } | ||
| 1296 | |||
| 1297 | state.type = _type; | ||
| 1298 | state.channel = _channel; | ||
| 1299 | } | ||
| 1300 | finally { | ||
| 1301 | } | ||
| 1302 | } | ||
| 1303 | // $ANTLR end "PlusSign" | ||
| 1304 | |||
| 1305 | // $ANTLR start "Comma" | ||
| 1306 | public final void mComma() throws RecognitionException { | ||
| 1307 | try { | ||
| 1308 | int _type = Comma; | ||
| 1309 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1310 | // InternalSolverLanguageLexer.g:128:7: ( ',' ) | ||
| 1311 | // InternalSolverLanguageLexer.g:128:9: ',' | ||
| 1312 | { | ||
| 1313 | match(','); | ||
| 1314 | |||
| 1315 | } | ||
| 1316 | |||
| 1317 | state.type = _type; | ||
| 1318 | state.channel = _channel; | ||
| 1319 | } | ||
| 1320 | finally { | ||
| 1321 | } | ||
| 1322 | } | ||
| 1323 | // $ANTLR end "Comma" | ||
| 1324 | |||
| 1325 | // $ANTLR start "HyphenMinus" | ||
| 1326 | public final void mHyphenMinus() throws RecognitionException { | ||
| 1327 | try { | ||
| 1328 | int _type = HyphenMinus; | ||
| 1329 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1330 | // InternalSolverLanguageLexer.g:130:13: ( '-' ) | ||
| 1331 | // InternalSolverLanguageLexer.g:130:15: '-' | ||
| 1332 | { | ||
| 1333 | match('-'); | ||
| 1334 | |||
| 1335 | } | ||
| 1336 | |||
| 1337 | state.type = _type; | ||
| 1338 | state.channel = _channel; | ||
| 1339 | } | ||
| 1340 | finally { | ||
| 1341 | } | ||
| 1342 | } | ||
| 1343 | // $ANTLR end "HyphenMinus" | ||
| 1344 | |||
| 1345 | // $ANTLR start "FullStop" | ||
| 1346 | public final void mFullStop() throws RecognitionException { | ||
| 1347 | try { | ||
| 1348 | int _type = FullStop; | ||
| 1349 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1350 | // InternalSolverLanguageLexer.g:132:10: ( '.' ) | ||
| 1351 | // InternalSolverLanguageLexer.g:132:12: '.' | ||
| 1352 | { | ||
| 1353 | match('.'); | ||
| 1354 | |||
| 1355 | } | ||
| 1356 | |||
| 1357 | state.type = _type; | ||
| 1358 | state.channel = _channel; | ||
| 1359 | } | ||
| 1360 | finally { | ||
| 1361 | } | ||
| 1362 | } | ||
| 1363 | // $ANTLR end "FullStop" | ||
| 1364 | |||
| 1365 | // $ANTLR start "Solidus" | ||
| 1366 | public final void mSolidus() throws RecognitionException { | ||
| 1367 | try { | ||
| 1368 | int _type = Solidus; | ||
| 1369 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1370 | // InternalSolverLanguageLexer.g:134:9: ( '/' ) | ||
| 1371 | // InternalSolverLanguageLexer.g:134:11: '/' | ||
| 1372 | { | ||
| 1373 | match('/'); | ||
| 1374 | |||
| 1375 | } | ||
| 1376 | |||
| 1377 | state.type = _type; | ||
| 1378 | state.channel = _channel; | ||
| 1379 | } | ||
| 1380 | finally { | ||
| 1381 | } | ||
| 1382 | } | ||
| 1383 | // $ANTLR end "Solidus" | ||
| 1384 | |||
| 1385 | // $ANTLR start "Colon" | ||
| 1386 | public final void mColon() throws RecognitionException { | ||
| 1387 | try { | ||
| 1388 | int _type = Colon; | ||
| 1389 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1390 | // InternalSolverLanguageLexer.g:136:7: ( ':' ) | ||
| 1391 | // InternalSolverLanguageLexer.g:136:9: ':' | ||
| 1392 | { | ||
| 1393 | match(':'); | ||
| 1394 | |||
| 1395 | } | ||
| 1396 | |||
| 1397 | state.type = _type; | ||
| 1398 | state.channel = _channel; | ||
| 1399 | } | ||
| 1400 | finally { | ||
| 1401 | } | ||
| 1402 | } | ||
| 1403 | // $ANTLR end "Colon" | ||
| 1404 | |||
| 1405 | // $ANTLR start "Semicolon" | ||
| 1406 | public final void mSemicolon() throws RecognitionException { | ||
| 1407 | try { | ||
| 1408 | int _type = Semicolon; | ||
| 1409 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1410 | // InternalSolverLanguageLexer.g:138:11: ( ';' ) | ||
| 1411 | // InternalSolverLanguageLexer.g:138:13: ';' | ||
| 1412 | { | ||
| 1413 | match(';'); | ||
| 1414 | |||
| 1415 | } | ||
| 1416 | |||
| 1417 | state.type = _type; | ||
| 1418 | state.channel = _channel; | ||
| 1419 | } | ||
| 1420 | finally { | ||
| 1421 | } | ||
| 1422 | } | ||
| 1423 | // $ANTLR end "Semicolon" | ||
| 1424 | |||
| 1425 | // $ANTLR start "LessThanSign" | ||
| 1426 | public final void mLessThanSign() throws RecognitionException { | ||
| 1427 | try { | ||
| 1428 | int _type = LessThanSign; | ||
| 1429 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1430 | // InternalSolverLanguageLexer.g:140:14: ( '<' ) | ||
| 1431 | // InternalSolverLanguageLexer.g:140:16: '<' | ||
| 1432 | { | ||
| 1433 | match('<'); | ||
| 1434 | |||
| 1435 | } | ||
| 1436 | |||
| 1437 | state.type = _type; | ||
| 1438 | state.channel = _channel; | ||
| 1439 | } | ||
| 1440 | finally { | ||
| 1441 | } | ||
| 1442 | } | ||
| 1443 | // $ANTLR end "LessThanSign" | ||
| 1444 | |||
| 1445 | // $ANTLR start "EqualsSign" | ||
| 1446 | public final void mEqualsSign() throws RecognitionException { | ||
| 1447 | try { | ||
| 1448 | int _type = EqualsSign; | ||
| 1449 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1450 | // InternalSolverLanguageLexer.g:142:12: ( '=' ) | ||
| 1451 | // InternalSolverLanguageLexer.g:142:14: '=' | ||
| 1452 | { | ||
| 1453 | match('='); | ||
| 1454 | |||
| 1455 | } | ||
| 1456 | |||
| 1457 | state.type = _type; | ||
| 1458 | state.channel = _channel; | ||
| 1459 | } | ||
| 1460 | finally { | ||
| 1461 | } | ||
| 1462 | } | ||
| 1463 | // $ANTLR end "EqualsSign" | ||
| 1464 | |||
| 1465 | // $ANTLR start "GreaterThanSign" | ||
| 1466 | public final void mGreaterThanSign() throws RecognitionException { | ||
| 1467 | try { | ||
| 1468 | int _type = GreaterThanSign; | ||
| 1469 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1470 | // InternalSolverLanguageLexer.g:144:17: ( '>' ) | ||
| 1471 | // InternalSolverLanguageLexer.g:144:19: '>' | ||
| 1472 | { | ||
| 1473 | match('>'); | ||
| 1474 | |||
| 1475 | } | ||
| 1476 | |||
| 1477 | state.type = _type; | ||
| 1478 | state.channel = _channel; | ||
| 1479 | } | ||
| 1480 | finally { | ||
| 1481 | } | ||
| 1482 | } | ||
| 1483 | // $ANTLR end "GreaterThanSign" | ||
| 1484 | |||
| 1485 | // $ANTLR start "LeftSquareBracket" | ||
| 1486 | public final void mLeftSquareBracket() throws RecognitionException { | ||
| 1487 | try { | ||
| 1488 | int _type = LeftSquareBracket; | ||
| 1489 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1490 | // InternalSolverLanguageLexer.g:146:19: ( '[' ) | ||
| 1491 | // InternalSolverLanguageLexer.g:146:21: '[' | ||
| 1492 | { | ||
| 1493 | match('['); | ||
| 1494 | |||
| 1495 | } | ||
| 1496 | |||
| 1497 | state.type = _type; | ||
| 1498 | state.channel = _channel; | ||
| 1499 | } | ||
| 1500 | finally { | ||
| 1501 | } | ||
| 1502 | } | ||
| 1503 | // $ANTLR end "LeftSquareBracket" | ||
| 1504 | |||
| 1505 | // $ANTLR start "RightSquareBracket" | ||
| 1506 | public final void mRightSquareBracket() throws RecognitionException { | ||
| 1507 | try { | ||
| 1508 | int _type = RightSquareBracket; | ||
| 1509 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1510 | // InternalSolverLanguageLexer.g:148:20: ( ']' ) | ||
| 1511 | // InternalSolverLanguageLexer.g:148:22: ']' | ||
| 1512 | { | ||
| 1513 | match(']'); | ||
| 1514 | |||
| 1515 | } | ||
| 1516 | |||
| 1517 | state.type = _type; | ||
| 1518 | state.channel = _channel; | ||
| 1519 | } | ||
| 1520 | finally { | ||
| 1521 | } | ||
| 1522 | } | ||
| 1523 | // $ANTLR end "RightSquareBracket" | ||
| 1524 | |||
| 1525 | // $ANTLR start "CircumflexAccent" | ||
| 1526 | public final void mCircumflexAccent() throws RecognitionException { | ||
| 1527 | try { | ||
| 1528 | int _type = CircumflexAccent; | ||
| 1529 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1530 | // InternalSolverLanguageLexer.g:150:18: ( '^' ) | ||
| 1531 | // InternalSolverLanguageLexer.g:150:20: '^' | ||
| 1532 | { | ||
| 1533 | match('^'); | ||
| 1534 | |||
| 1535 | } | ||
| 1536 | |||
| 1537 | state.type = _type; | ||
| 1538 | state.channel = _channel; | ||
| 1539 | } | ||
| 1540 | finally { | ||
| 1541 | } | ||
| 1542 | } | ||
| 1543 | // $ANTLR end "CircumflexAccent" | ||
| 1544 | |||
| 1545 | // $ANTLR start "LeftCurlyBracket" | ||
| 1546 | public final void mLeftCurlyBracket() throws RecognitionException { | ||
| 1547 | try { | ||
| 1548 | int _type = LeftCurlyBracket; | ||
| 1549 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1550 | // InternalSolverLanguageLexer.g:152:18: ( '{' ) | ||
| 1551 | // InternalSolverLanguageLexer.g:152:20: '{' | ||
| 1552 | { | ||
| 1553 | match('{'); | ||
| 1554 | |||
| 1555 | } | ||
| 1556 | |||
| 1557 | state.type = _type; | ||
| 1558 | state.channel = _channel; | ||
| 1559 | } | ||
| 1560 | finally { | ||
| 1561 | } | ||
| 1562 | } | ||
| 1563 | // $ANTLR end "LeftCurlyBracket" | ||
| 1564 | |||
| 1565 | // $ANTLR start "VerticalLine" | ||
| 1566 | public final void mVerticalLine() throws RecognitionException { | ||
| 1567 | try { | ||
| 1568 | int _type = VerticalLine; | ||
| 1569 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1570 | // InternalSolverLanguageLexer.g:154:14: ( '|' ) | ||
| 1571 | // InternalSolverLanguageLexer.g:154:16: '|' | ||
| 1572 | { | ||
| 1573 | match('|'); | ||
| 1574 | |||
| 1575 | } | ||
| 1576 | |||
| 1577 | state.type = _type; | ||
| 1578 | state.channel = _channel; | ||
| 1579 | } | ||
| 1580 | finally { | ||
| 1581 | } | ||
| 1582 | } | ||
| 1583 | // $ANTLR end "VerticalLine" | ||
| 1584 | |||
| 1585 | // $ANTLR start "RightCurlyBracket" | ||
| 1586 | public final void mRightCurlyBracket() throws RecognitionException { | ||
| 1587 | try { | ||
| 1588 | int _type = RightCurlyBracket; | ||
| 1589 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1590 | // InternalSolverLanguageLexer.g:156:19: ( '}' ) | ||
| 1591 | // InternalSolverLanguageLexer.g:156:21: '}' | ||
| 1592 | { | ||
| 1593 | match('}'); | ||
| 1594 | |||
| 1595 | } | ||
| 1596 | |||
| 1597 | state.type = _type; | ||
| 1598 | state.channel = _channel; | ||
| 1599 | } | ||
| 1600 | finally { | ||
| 1601 | } | ||
| 1602 | } | ||
| 1603 | // $ANTLR end "RightCurlyBracket" | ||
| 1604 | |||
| 1605 | // $ANTLR start "RULE_STRING" | ||
| 1606 | public final void mRULE_STRING() throws RecognitionException { | ||
| 1607 | try { | ||
| 1608 | int _type = RULE_STRING; | ||
| 1609 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1610 | // InternalSolverLanguageLexer.g:158:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
| 1611 | // InternalSolverLanguageLexer.g:158:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
| 1612 | { | ||
| 1613 | match('\"'); | ||
| 1614 | // InternalSolverLanguageLexer.g:158:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
| 1615 | loop1: | ||
| 1616 | do { | ||
| 1617 | int alt1=3; | ||
| 1618 | int LA1_0 = input.LA(1); | ||
| 1619 | |||
| 1620 | if ( (LA1_0=='\\') ) { | ||
| 1621 | alt1=1; | ||
| 1622 | } | ||
| 1623 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
| 1624 | alt1=2; | ||
| 1625 | } | ||
| 1626 | |||
| 1627 | |||
| 1628 | switch (alt1) { | ||
| 1629 | case 1 : | ||
| 1630 | // InternalSolverLanguageLexer.g:158:20: '\\\\' . | ||
| 1631 | { | ||
| 1632 | match('\\'); | ||
| 1633 | matchAny(); | ||
| 1634 | |||
| 1635 | } | ||
| 1636 | break; | ||
| 1637 | case 2 : | ||
| 1638 | // InternalSolverLanguageLexer.g:158:27: ~ ( ( '\\\\' | '\"' ) ) | ||
| 1639 | { | ||
| 1640 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
| 1641 | input.consume(); | ||
| 1642 | |||
| 1643 | } | ||
| 1644 | else { | ||
| 1645 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1646 | recover(mse); | ||
| 1647 | throw mse;} | ||
| 1648 | |||
| 1649 | |||
| 1650 | } | ||
| 1651 | break; | ||
| 1652 | |||
| 1653 | default : | ||
| 1654 | break loop1; | ||
| 1655 | } | ||
| 1656 | } while (true); | ||
| 1657 | |||
| 1658 | match('\"'); | ||
| 1659 | |||
| 1660 | } | ||
| 1661 | |||
| 1662 | state.type = _type; | ||
| 1663 | state.channel = _channel; | ||
| 1664 | } | ||
| 1665 | finally { | ||
| 1666 | } | ||
| 1667 | } | ||
| 1668 | // $ANTLR end "RULE_STRING" | ||
| 1669 | |||
| 1670 | // $ANTLR start "RULE_QUOTED_ID" | ||
| 1671 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
| 1672 | try { | ||
| 1673 | int _type = RULE_QUOTED_ID; | ||
| 1674 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1675 | // InternalSolverLanguageLexer.g:160:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
| 1676 | // InternalSolverLanguageLexer.g:160:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
| 1677 | { | ||
| 1678 | match('\''); | ||
| 1679 | // InternalSolverLanguageLexer.g:160:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
| 1680 | loop2: | ||
| 1681 | do { | ||
| 1682 | int alt2=3; | ||
| 1683 | int LA2_0 = input.LA(1); | ||
| 1684 | |||
| 1685 | if ( (LA2_0=='\\') ) { | ||
| 1686 | alt2=1; | ||
| 1687 | } | ||
| 1688 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | ||
| 1689 | alt2=2; | ||
| 1690 | } | ||
| 1691 | |||
| 1692 | |||
| 1693 | switch (alt2) { | ||
| 1694 | case 1 : | ||
| 1695 | // InternalSolverLanguageLexer.g:160:24: '\\\\' . | ||
| 1696 | { | ||
| 1697 | match('\\'); | ||
| 1698 | matchAny(); | ||
| 1699 | |||
| 1700 | } | ||
| 1701 | break; | ||
| 1702 | case 2 : | ||
| 1703 | // InternalSolverLanguageLexer.g:160:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
| 1704 | { | ||
| 1705 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
| 1706 | input.consume(); | ||
| 1707 | |||
| 1708 | } | ||
| 1709 | else { | ||
| 1710 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1711 | recover(mse); | ||
| 1712 | throw mse;} | ||
| 1713 | |||
| 1714 | |||
| 1715 | } | ||
| 1716 | break; | ||
| 1717 | |||
| 1718 | default : | ||
| 1719 | break loop2; | ||
| 1720 | } | ||
| 1721 | } while (true); | ||
| 1722 | |||
| 1723 | match('\''); | ||
| 1724 | |||
| 1725 | } | ||
| 1726 | |||
| 1727 | state.type = _type; | ||
| 1728 | state.channel = _channel; | ||
| 1729 | } | ||
| 1730 | finally { | ||
| 1731 | } | ||
| 1732 | } | ||
| 1733 | // $ANTLR end "RULE_QUOTED_ID" | ||
| 1734 | |||
| 1735 | // $ANTLR start "RULE_SL_COMMENT" | ||
| 1736 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
| 1737 | try { | ||
| 1738 | int _type = RULE_SL_COMMENT; | ||
| 1739 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1740 | // InternalSolverLanguageLexer.g:162:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
| 1741 | // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
| 1742 | { | ||
| 1743 | // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' ) | ||
| 1744 | int alt3=2; | ||
| 1745 | int LA3_0 = input.LA(1); | ||
| 1746 | |||
| 1747 | if ( (LA3_0=='%') ) { | ||
| 1748 | alt3=1; | ||
| 1749 | } | ||
| 1750 | else if ( (LA3_0=='/') ) { | ||
| 1751 | alt3=2; | ||
| 1752 | } | ||
| 1753 | else { | ||
| 1754 | NoViableAltException nvae = | ||
| 1755 | new NoViableAltException("", 3, 0, input); | ||
| 1756 | |||
| 1757 | throw nvae; | ||
| 1758 | } | ||
| 1759 | switch (alt3) { | ||
| 1760 | case 1 : | ||
| 1761 | // InternalSolverLanguageLexer.g:162:20: '%' | ||
| 1762 | { | ||
| 1763 | match('%'); | ||
| 1764 | |||
| 1765 | } | ||
| 1766 | break; | ||
| 1767 | case 2 : | ||
| 1768 | // InternalSolverLanguageLexer.g:162:24: '//' | ||
| 1769 | { | ||
| 1770 | match("//"); | ||
| 1771 | |||
| 1772 | |||
| 1773 | } | ||
| 1774 | break; | ||
| 1775 | |||
| 1776 | } | ||
| 1777 | |||
| 1778 | // InternalSolverLanguageLexer.g:162:30: (~ ( ( '\\n' | '\\r' ) ) )* | ||
| 1779 | loop4: | ||
| 1780 | do { | ||
| 1781 | int alt4=2; | ||
| 1782 | int LA4_0 = input.LA(1); | ||
| 1783 | |||
| 1784 | if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) { | ||
| 1785 | alt4=1; | ||
| 1786 | } | ||
| 1787 | |||
| 1788 | |||
| 1789 | switch (alt4) { | ||
| 1790 | case 1 : | ||
| 1791 | // InternalSolverLanguageLexer.g:162:30: ~ ( ( '\\n' | '\\r' ) ) | ||
| 1792 | { | ||
| 1793 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { | ||
| 1794 | input.consume(); | ||
| 1795 | |||
| 1796 | } | ||
| 1797 | else { | ||
| 1798 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1799 | recover(mse); | ||
| 1800 | throw mse;} | ||
| 1801 | |||
| 1802 | |||
| 1803 | } | ||
| 1804 | break; | ||
| 1805 | |||
| 1806 | default : | ||
| 1807 | break loop4; | ||
| 1808 | } | ||
| 1809 | } while (true); | ||
| 1810 | |||
| 1811 | // InternalSolverLanguageLexer.g:162:46: ( ( '\\r' )? '\\n' )? | ||
| 1812 | int alt6=2; | ||
| 1813 | int LA6_0 = input.LA(1); | ||
| 1814 | |||
| 1815 | if ( (LA6_0=='\n'||LA6_0=='\r') ) { | ||
| 1816 | alt6=1; | ||
| 1817 | } | ||
| 1818 | switch (alt6) { | ||
| 1819 | case 1 : | ||
| 1820 | // InternalSolverLanguageLexer.g:162:47: ( '\\r' )? '\\n' | ||
| 1821 | { | ||
| 1822 | // InternalSolverLanguageLexer.g:162:47: ( '\\r' )? | ||
| 1823 | int alt5=2; | ||
| 1824 | int LA5_0 = input.LA(1); | ||
| 1825 | |||
| 1826 | if ( (LA5_0=='\r') ) { | ||
| 1827 | alt5=1; | ||
| 1828 | } | ||
| 1829 | switch (alt5) { | ||
| 1830 | case 1 : | ||
| 1831 | // InternalSolverLanguageLexer.g:162:47: '\\r' | ||
| 1832 | { | ||
| 1833 | match('\r'); | ||
| 1834 | |||
| 1835 | } | ||
| 1836 | break; | ||
| 1837 | |||
| 1838 | } | ||
| 1839 | |||
| 1840 | match('\n'); | ||
| 1841 | |||
| 1842 | } | ||
| 1843 | break; | ||
| 1844 | |||
| 1845 | } | ||
| 1846 | |||
| 1847 | |||
| 1848 | } | ||
| 1849 | |||
| 1850 | state.type = _type; | ||
| 1851 | state.channel = _channel; | ||
| 1852 | } | ||
| 1853 | finally { | ||
| 1854 | } | ||
| 1855 | } | ||
| 1856 | // $ANTLR end "RULE_SL_COMMENT" | ||
| 1857 | |||
| 1858 | // $ANTLR start "RULE_TRANSITIVE_CLOSURE" | ||
| 1859 | public final void mRULE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
| 1860 | try { | ||
| 1861 | // InternalSolverLanguageLexer.g:164:34: () | ||
| 1862 | // InternalSolverLanguageLexer.g:164:36: | ||
| 1863 | { | ||
| 1864 | } | ||
| 1865 | |||
| 1866 | } | ||
| 1867 | finally { | ||
| 1868 | } | ||
| 1869 | } | ||
| 1870 | // $ANTLR end "RULE_TRANSITIVE_CLOSURE" | ||
| 1871 | |||
| 1872 | // $ANTLR start "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
| 1873 | public final void mRULE_REFLEXIVE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
| 1874 | try { | ||
| 1875 | // InternalSolverLanguageLexer.g:166:44: () | ||
| 1876 | // InternalSolverLanguageLexer.g:166:46: | ||
| 1877 | { | ||
| 1878 | } | ||
| 1879 | |||
| 1880 | } | ||
| 1881 | finally { | ||
| 1882 | } | ||
| 1883 | } | ||
| 1884 | // $ANTLR end "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
| 1885 | |||
| 1886 | // $ANTLR start "RULE_FULL_STOP" | ||
| 1887 | public final void mRULE_FULL_STOP() throws RecognitionException { | ||
| 1888 | try { | ||
| 1889 | // InternalSolverLanguageLexer.g:168:25: () | ||
| 1890 | // InternalSolverLanguageLexer.g:168:27: | ||
| 1891 | { | ||
| 1892 | } | ||
| 1893 | |||
| 1894 | } | ||
| 1895 | finally { | ||
| 1896 | } | ||
| 1897 | } | ||
| 1898 | // $ANTLR end "RULE_FULL_STOP" | ||
| 1899 | |||
| 1900 | // $ANTLR start "RULE_ID" | ||
| 1901 | public final void mRULE_ID() throws RecognitionException { | ||
| 1902 | try { | ||
| 1903 | int _type = RULE_ID; | ||
| 1904 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1905 | // InternalSolverLanguageLexer.g:170:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
| 1906 | // InternalSolverLanguageLexer.g:170:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 1907 | { | ||
| 1908 | // InternalSolverLanguageLexer.g:170:11: ( '^' )? | ||
| 1909 | int alt7=2; | ||
| 1910 | int LA7_0 = input.LA(1); | ||
| 1911 | |||
| 1912 | if ( (LA7_0=='^') ) { | ||
| 1913 | alt7=1; | ||
| 1914 | } | ||
| 1915 | switch (alt7) { | ||
| 1916 | case 1 : | ||
| 1917 | // InternalSolverLanguageLexer.g:170:11: '^' | ||
| 1918 | { | ||
| 1919 | match('^'); | ||
| 1920 | |||
| 1921 | } | ||
| 1922 | break; | ||
| 1923 | |||
| 1924 | } | ||
| 1925 | |||
| 1926 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 1927 | input.consume(); | ||
| 1928 | |||
| 1929 | } | ||
| 1930 | else { | ||
| 1931 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1932 | recover(mse); | ||
| 1933 | throw mse;} | ||
| 1934 | |||
| 1935 | // InternalSolverLanguageLexer.g:170:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
| 1936 | loop8: | ||
| 1937 | do { | ||
| 1938 | int alt8=2; | ||
| 1939 | int LA8_0 = input.LA(1); | ||
| 1940 | |||
| 1941 | if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) { | ||
| 1942 | alt8=1; | ||
| 1943 | } | ||
| 1944 | |||
| 1945 | |||
| 1946 | switch (alt8) { | ||
| 1947 | case 1 : | ||
| 1948 | // InternalSolverLanguageLexer.g: | ||
| 1949 | { | ||
| 1950 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
| 1951 | input.consume(); | ||
| 1952 | |||
| 1953 | } | ||
| 1954 | else { | ||
| 1955 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 1956 | recover(mse); | ||
| 1957 | throw mse;} | ||
| 1958 | |||
| 1959 | |||
| 1960 | } | ||
| 1961 | break; | ||
| 1962 | |||
| 1963 | default : | ||
| 1964 | break loop8; | ||
| 1965 | } | ||
| 1966 | } while (true); | ||
| 1967 | |||
| 1968 | |||
| 1969 | } | ||
| 1970 | |||
| 1971 | state.type = _type; | ||
| 1972 | state.channel = _channel; | ||
| 1973 | } | ||
| 1974 | finally { | ||
| 1975 | } | ||
| 1976 | } | ||
| 1977 | // $ANTLR end "RULE_ID" | ||
| 1978 | |||
| 1979 | // $ANTLR start "RULE_INT" | ||
| 1980 | public final void mRULE_INT() throws RecognitionException { | ||
| 1981 | try { | ||
| 1982 | int _type = RULE_INT; | ||
| 1983 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 1984 | // InternalSolverLanguageLexer.g:172:10: ( ( '0' .. '9' )+ ) | ||
| 1985 | // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+ | ||
| 1986 | { | ||
| 1987 | // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+ | ||
| 1988 | int cnt9=0; | ||
| 1989 | loop9: | ||
| 1990 | do { | ||
| 1991 | int alt9=2; | ||
| 1992 | int LA9_0 = input.LA(1); | ||
| 1993 | |||
| 1994 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
| 1995 | alt9=1; | ||
| 1996 | } | ||
| 1997 | |||
| 1998 | |||
| 1999 | switch (alt9) { | ||
| 2000 | case 1 : | ||
| 2001 | // InternalSolverLanguageLexer.g:172:13: '0' .. '9' | ||
| 2002 | { | ||
| 2003 | matchRange('0','9'); | ||
| 2004 | |||
| 2005 | } | ||
| 2006 | break; | ||
| 2007 | |||
| 2008 | default : | ||
| 2009 | if ( cnt9 >= 1 ) break loop9; | ||
| 2010 | EarlyExitException eee = | ||
| 2011 | new EarlyExitException(9, input); | ||
| 2012 | throw eee; | ||
| 2013 | } | ||
| 2014 | cnt9++; | ||
| 2015 | } while (true); | ||
| 2016 | |||
| 2017 | |||
| 2018 | } | ||
| 2019 | |||
| 2020 | state.type = _type; | ||
| 2021 | state.channel = _channel; | ||
| 2022 | } | ||
| 2023 | finally { | ||
| 2024 | } | ||
| 2025 | } | ||
| 2026 | // $ANTLR end "RULE_INT" | ||
| 2027 | |||
| 2028 | // $ANTLR start "RULE_ML_COMMENT" | ||
| 2029 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
| 2030 | try { | ||
| 2031 | int _type = RULE_ML_COMMENT; | ||
| 2032 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 2033 | // InternalSolverLanguageLexer.g:174:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
| 2034 | // InternalSolverLanguageLexer.g:174:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
| 2035 | { | ||
| 2036 | match("/*"); | ||
| 2037 | |||
| 2038 | // InternalSolverLanguageLexer.g:174:24: ( options {greedy=false; } : . )* | ||
| 2039 | loop10: | ||
| 2040 | do { | ||
| 2041 | int alt10=2; | ||
| 2042 | int LA10_0 = input.LA(1); | ||
| 2043 | |||
| 2044 | if ( (LA10_0=='*') ) { | ||
| 2045 | int LA10_1 = input.LA(2); | ||
| 2046 | |||
| 2047 | if ( (LA10_1=='/') ) { | ||
| 2048 | alt10=2; | ||
| 2049 | } | ||
| 2050 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | ||
| 2051 | alt10=1; | ||
| 2052 | } | ||
| 2053 | |||
| 2054 | |||
| 2055 | } | ||
| 2056 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | ||
| 2057 | alt10=1; | ||
| 2058 | } | ||
| 2059 | |||
| 2060 | |||
| 2061 | switch (alt10) { | ||
| 2062 | case 1 : | ||
| 2063 | // InternalSolverLanguageLexer.g:174:52: . | ||
| 2064 | { | ||
| 2065 | matchAny(); | ||
| 2066 | |||
| 2067 | } | ||
| 2068 | break; | ||
| 2069 | |||
| 2070 | default : | ||
| 2071 | break loop10; | ||
| 2072 | } | ||
| 2073 | } while (true); | ||
| 2074 | |||
| 2075 | match("*/"); | ||
| 2076 | |||
| 2077 | |||
| 2078 | } | ||
| 2079 | |||
| 2080 | state.type = _type; | ||
| 2081 | state.channel = _channel; | ||
| 2082 | } | ||
| 2083 | finally { | ||
| 2084 | } | ||
| 2085 | } | ||
| 2086 | // $ANTLR end "RULE_ML_COMMENT" | ||
| 2087 | |||
| 2088 | // $ANTLR start "RULE_WS" | ||
| 2089 | public final void mRULE_WS() throws RecognitionException { | ||
| 2090 | try { | ||
| 2091 | int _type = RULE_WS; | ||
| 2092 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 2093 | // InternalSolverLanguageLexer.g:176:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
| 2094 | // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 2095 | { | ||
| 2096 | // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
| 2097 | int cnt11=0; | ||
| 2098 | loop11: | ||
| 2099 | do { | ||
| 2100 | int alt11=2; | ||
| 2101 | int LA11_0 = input.LA(1); | ||
| 2102 | |||
| 2103 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | ||
| 2104 | alt11=1; | ||
| 2105 | } | ||
| 2106 | |||
| 2107 | |||
| 2108 | switch (alt11) { | ||
| 2109 | case 1 : | ||
| 2110 | // InternalSolverLanguageLexer.g: | ||
| 2111 | { | ||
| 2112 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
| 2113 | input.consume(); | ||
| 2114 | |||
| 2115 | } | ||
| 2116 | else { | ||
| 2117 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
| 2118 | recover(mse); | ||
| 2119 | throw mse;} | ||
| 2120 | |||
| 2121 | |||
| 2122 | } | ||
| 2123 | break; | ||
| 2124 | |||
| 2125 | default : | ||
| 2126 | if ( cnt11 >= 1 ) break loop11; | ||
| 2127 | EarlyExitException eee = | ||
| 2128 | new EarlyExitException(11, input); | ||
| 2129 | throw eee; | ||
| 2130 | } | ||
| 2131 | cnt11++; | ||
| 2132 | } while (true); | ||
| 2133 | |||
| 2134 | |||
| 2135 | } | ||
| 2136 | |||
| 2137 | state.type = _type; | ||
| 2138 | state.channel = _channel; | ||
| 2139 | } | ||
| 2140 | finally { | ||
| 2141 | } | ||
| 2142 | } | ||
| 2143 | // $ANTLR end "RULE_WS" | ||
| 2144 | |||
| 2145 | // $ANTLR start "RULE_ANY_OTHER" | ||
| 2146 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
| 2147 | try { | ||
| 2148 | int _type = RULE_ANY_OTHER; | ||
| 2149 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
| 2150 | // InternalSolverLanguageLexer.g:178:16: ( . ) | ||
| 2151 | // InternalSolverLanguageLexer.g:178:18: . | ||
| 2152 | { | ||
| 2153 | matchAny(); | ||
| 2154 | |||
| 2155 | } | ||
| 2156 | |||
| 2157 | state.type = _type; | ||
| 2158 | state.channel = _channel; | ||
| 2159 | } | ||
| 2160 | finally { | ||
| 2161 | } | ||
| 2162 | } | ||
| 2163 | // $ANTLR end "RULE_ANY_OTHER" | ||
| 2164 | |||
| 2165 | public void mTokens() throws RecognitionException { | ||
| 2166 | // InternalSolverLanguageLexer.g:1:8: ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
| 2167 | int alt12=80; | ||
| 2168 | alt12 = dfa12.predict(input); | ||
| 2169 | switch (alt12) { | ||
| 2170 | case 1 : | ||
| 2171 | // InternalSolverLanguageLexer.g:1:10: GREATER_EQ | ||
| 2172 | { | ||
| 2173 | mGREATER_EQ(); | ||
| 2174 | |||
| 2175 | } | ||
| 2176 | break; | ||
| 2177 | case 2 : | ||
| 2178 | // InternalSolverLanguageLexer.g:1:21: Functional | ||
| 2179 | { | ||
| 2180 | mFunctional(); | ||
| 2181 | |||
| 2182 | } | ||
| 2183 | break; | ||
| 2184 | case 3 : | ||
| 2185 | // InternalSolverLanguageLexer.g:1:32: Abstract | ||
| 2186 | { | ||
| 2187 | mAbstract(); | ||
| 2188 | |||
| 2189 | } | ||
| 2190 | break; | ||
| 2191 | case 4 : | ||
| 2192 | // InternalSolverLanguageLexer.g:1:41: Contains | ||
| 2193 | { | ||
| 2194 | mContains(); | ||
| 2195 | |||
| 2196 | } | ||
| 2197 | break; | ||
| 2198 | case 5 : | ||
| 2199 | // InternalSolverLanguageLexer.g:1:50: Maximize | ||
| 2200 | { | ||
| 2201 | mMaximize(); | ||
| 2202 | |||
| 2203 | } | ||
| 2204 | break; | ||
| 2205 | case 6 : | ||
| 2206 | // InternalSolverLanguageLexer.g:1:59: Minimize | ||
| 2207 | { | ||
| 2208 | mMinimize(); | ||
| 2209 | |||
| 2210 | } | ||
| 2211 | break; | ||
| 2212 | case 7 : | ||
| 2213 | // InternalSolverLanguageLexer.g:1:68: Opposite | ||
| 2214 | { | ||
| 2215 | mOpposite(); | ||
| 2216 | |||
| 2217 | } | ||
| 2218 | break; | ||
| 2219 | case 8 : | ||
| 2220 | // InternalSolverLanguageLexer.g:1:77: GREATER | ||
| 2221 | { | ||
| 2222 | mGREATER(); | ||
| 2223 | |||
| 2224 | } | ||
| 2225 | break; | ||
| 2226 | case 9 : | ||
| 2227 | // InternalSolverLanguageLexer.g:1:85: LESS_EQ | ||
| 2228 | { | ||
| 2229 | mLESS_EQ(); | ||
| 2230 | |||
| 2231 | } | ||
| 2232 | break; | ||
| 2233 | case 10 : | ||
| 2234 | // InternalSolverLanguageLexer.g:1:93: Current | ||
| 2235 | { | ||
| 2236 | mCurrent(); | ||
| 2237 | |||
| 2238 | } | ||
| 2239 | break; | ||
| 2240 | case 11 : | ||
| 2241 | // InternalSolverLanguageLexer.g:1:101: Default | ||
| 2242 | { | ||
| 2243 | mDefault(); | ||
| 2244 | |||
| 2245 | } | ||
| 2246 | break; | ||
| 2247 | case 12 : | ||
| 2248 | // InternalSolverLanguageLexer.g:1:109: Extends | ||
| 2249 | { | ||
| 2250 | mExtends(); | ||
| 2251 | |||
| 2252 | } | ||
| 2253 | break; | ||
| 2254 | case 13 : | ||
| 2255 | // InternalSolverLanguageLexer.g:1:117: Unknown | ||
| 2256 | { | ||
| 2257 | mUnknown(); | ||
| 2258 | |||
| 2259 | } | ||
| 2260 | break; | ||
| 2261 | case 14 : | ||
| 2262 | // InternalSolverLanguageLexer.g:1:125: NOT_EQ | ||
| 2263 | { | ||
| 2264 | mNOT_EQ(); | ||
| 2265 | |||
| 2266 | } | ||
| 2267 | break; | ||
| 2268 | case 15 : | ||
| 2269 | // InternalSolverLanguageLexer.g:1:132: Extern | ||
| 2270 | { | ||
| 2271 | mExtern(); | ||
| 2272 | |||
| 2273 | } | ||
| 2274 | break; | ||
| 2275 | case 16 : | ||
| 2276 | // InternalSolverLanguageLexer.g:1:139: Class | ||
| 2277 | { | ||
| 2278 | mClass(); | ||
| 2279 | |||
| 2280 | } | ||
| 2281 | break; | ||
| 2282 | case 17 : | ||
| 2283 | // InternalSolverLanguageLexer.g:1:145: Count | ||
| 2284 | { | ||
| 2285 | mCount(); | ||
| 2286 | |||
| 2287 | } | ||
| 2288 | break; | ||
| 2289 | case 18 : | ||
| 2290 | // InternalSolverLanguageLexer.g:1:151: Empty | ||
| 2291 | { | ||
| 2292 | mEmpty(); | ||
| 2293 | |||
| 2294 | } | ||
| 2295 | break; | ||
| 2296 | case 19 : | ||
| 2297 | // InternalSolverLanguageLexer.g:1:157: Error | ||
| 2298 | { | ||
| 2299 | mError(); | ||
| 2300 | |||
| 2301 | } | ||
| 2302 | break; | ||
| 2303 | case 20 : | ||
| 2304 | // InternalSolverLanguageLexer.g:1:163: False | ||
| 2305 | { | ||
| 2306 | mFalse(); | ||
| 2307 | |||
| 2308 | } | ||
| 2309 | break; | ||
| 2310 | case 21 : | ||
| 2311 | // InternalSolverLanguageLexer.g:1:169: Scope | ||
| 2312 | { | ||
| 2313 | mScope(); | ||
| 2314 | |||
| 2315 | } | ||
| 2316 | break; | ||
| 2317 | case 22 : | ||
| 2318 | // InternalSolverLanguageLexer.g:1:175: LESS | ||
| 2319 | { | ||
| 2320 | mLESS(); | ||
| 2321 | |||
| 2322 | } | ||
| 2323 | break; | ||
| 2324 | case 23 : | ||
| 2325 | // InternalSolverLanguageLexer.g:1:180: Else | ||
| 2326 | { | ||
| 2327 | mElse(); | ||
| 2328 | |||
| 2329 | } | ||
| 2330 | break; | ||
| 2331 | case 24 : | ||
| 2332 | // InternalSolverLanguageLexer.g:1:185: Must | ||
| 2333 | { | ||
| 2334 | mMust(); | ||
| 2335 | |||
| 2336 | } | ||
| 2337 | break; | ||
| 2338 | case 25 : | ||
| 2339 | // InternalSolverLanguageLexer.g:1:190: Only | ||
| 2340 | { | ||
| 2341 | mOnly(); | ||
| 2342 | |||
| 2343 | } | ||
| 2344 | break; | ||
| 2345 | case 26 : | ||
| 2346 | // InternalSolverLanguageLexer.g:1:195: Prod | ||
| 2347 | { | ||
| 2348 | mProd(); | ||
| 2349 | |||
| 2350 | } | ||
| 2351 | break; | ||
| 2352 | case 27 : | ||
| 2353 | // InternalSolverLanguageLexer.g:1:200: Real | ||
| 2354 | { | ||
| 2355 | mReal(); | ||
| 2356 | |||
| 2357 | } | ||
| 2358 | break; | ||
| 2359 | case 28 : | ||
| 2360 | // InternalSolverLanguageLexer.g:1:205: Then | ||
| 2361 | { | ||
| 2362 | mThen(); | ||
| 2363 | |||
| 2364 | } | ||
| 2365 | break; | ||
| 2366 | case 29 : | ||
| 2367 | // InternalSolverLanguageLexer.g:1:210: True | ||
| 2368 | { | ||
| 2369 | mTrue(); | ||
| 2370 | |||
| 2371 | } | ||
| 2372 | break; | ||
| 2373 | case 30 : | ||
| 2374 | // InternalSolverLanguageLexer.g:1:215: ADD | ||
| 2375 | { | ||
| 2376 | mADD(); | ||
| 2377 | |||
| 2378 | } | ||
| 2379 | break; | ||
| 2380 | case 31 : | ||
| 2381 | // InternalSolverLanguageLexer.g:1:219: DIV | ||
| 2382 | { | ||
| 2383 | mDIV(); | ||
| 2384 | |||
| 2385 | } | ||
| 2386 | break; | ||
| 2387 | case 32 : | ||
| 2388 | // InternalSolverLanguageLexer.g:1:223: MUL | ||
| 2389 | { | ||
| 2390 | mMUL(); | ||
| 2391 | |||
| 2392 | } | ||
| 2393 | break; | ||
| 2394 | case 33 : | ||
| 2395 | // InternalSolverLanguageLexer.g:1:227: POW | ||
| 2396 | { | ||
| 2397 | mPOW(); | ||
| 2398 | |||
| 2399 | } | ||
| 2400 | break; | ||
| 2401 | case 34 : | ||
| 2402 | // InternalSolverLanguageLexer.g:1:231: SUB | ||
| 2403 | { | ||
| 2404 | mSUB(); | ||
| 2405 | |||
| 2406 | } | ||
| 2407 | break; | ||
| 2408 | case 35 : | ||
| 2409 | // InternalSolverLanguageLexer.g:1:235: Avg | ||
| 2410 | { | ||
| 2411 | mAvg(); | ||
| 2412 | |||
| 2413 | } | ||
| 2414 | break; | ||
| 2415 | case 36 : | ||
| 2416 | // InternalSolverLanguageLexer.g:1:239: Inf | ||
| 2417 | { | ||
| 2418 | mInf(); | ||
| 2419 | |||
| 2420 | } | ||
| 2421 | break; | ||
| 2422 | case 37 : | ||
| 2423 | // InternalSolverLanguageLexer.g:1:243: Int | ||
| 2424 | { | ||
| 2425 | mInt(); | ||
| 2426 | |||
| 2427 | } | ||
| 2428 | break; | ||
| 2429 | case 38 : | ||
| 2430 | // InternalSolverLanguageLexer.g:1:247: Max | ||
| 2431 | { | ||
| 2432 | mMax(); | ||
| 2433 | |||
| 2434 | } | ||
| 2435 | break; | ||
| 2436 | case 39 : | ||
| 2437 | // InternalSolverLanguageLexer.g:1:251: May | ||
| 2438 | { | ||
| 2439 | mMay(); | ||
| 2440 | |||
| 2441 | } | ||
| 2442 | break; | ||
| 2443 | case 40 : | ||
| 2444 | // InternalSolverLanguageLexer.g:1:255: Min | ||
| 2445 | { | ||
| 2446 | mMin(); | ||
| 2447 | |||
| 2448 | } | ||
| 2449 | break; | ||
| 2450 | case 41 : | ||
| 2451 | // InternalSolverLanguageLexer.g:1:259: Sum | ||
| 2452 | { | ||
| 2453 | mSum(); | ||
| 2454 | |||
| 2455 | } | ||
| 2456 | break; | ||
| 2457 | case 42 : | ||
| 2458 | // InternalSolverLanguageLexer.g:1:263: ExclamationMarkEqualsSign | ||
| 2459 | { | ||
| 2460 | mExclamationMarkEqualsSign(); | ||
| 2461 | |||
| 2462 | } | ||
| 2463 | break; | ||
| 2464 | case 43 : | ||
| 2465 | // InternalSolverLanguageLexer.g:1:289: HyphenMinusGreaterThanSign | ||
| 2466 | { | ||
| 2467 | mHyphenMinusGreaterThanSign(); | ||
| 2468 | |||
| 2469 | } | ||
| 2470 | break; | ||
| 2471 | case 44 : | ||
| 2472 | // InternalSolverLanguageLexer.g:1:316: FullStopFullStop | ||
| 2473 | { | ||
| 2474 | mFullStopFullStop(); | ||
| 2475 | |||
| 2476 | } | ||
| 2477 | break; | ||
| 2478 | case 45 : | ||
| 2479 | // InternalSolverLanguageLexer.g:1:333: ColonHyphenMinus | ||
| 2480 | { | ||
| 2481 | mColonHyphenMinus(); | ||
| 2482 | |||
| 2483 | } | ||
| 2484 | break; | ||
| 2485 | case 46 : | ||
| 2486 | // InternalSolverLanguageLexer.g:1:350: LessThanSignEqualsSign | ||
| 2487 | { | ||
| 2488 | mLessThanSignEqualsSign(); | ||
| 2489 | |||
| 2490 | } | ||
| 2491 | break; | ||
| 2492 | case 47 : | ||
| 2493 | // InternalSolverLanguageLexer.g:1:373: EqualsSignEqualsSign | ||
| 2494 | { | ||
| 2495 | mEqualsSignEqualsSign(); | ||
| 2496 | |||
| 2497 | } | ||
| 2498 | break; | ||
| 2499 | case 48 : | ||
| 2500 | // InternalSolverLanguageLexer.g:1:394: GreaterThanSignEqualsSign | ||
| 2501 | { | ||
| 2502 | mGreaterThanSignEqualsSign(); | ||
| 2503 | |||
| 2504 | } | ||
| 2505 | break; | ||
| 2506 | case 49 : | ||
| 2507 | // InternalSolverLanguageLexer.g:1:420: EQ | ||
| 2508 | { | ||
| 2509 | mEQ(); | ||
| 2510 | |||
| 2511 | } | ||
| 2512 | break; | ||
| 2513 | case 50 : | ||
| 2514 | // InternalSolverLanguageLexer.g:1:423: IN | ||
| 2515 | { | ||
| 2516 | mIN(); | ||
| 2517 | |||
| 2518 | } | ||
| 2519 | break; | ||
| 2520 | case 51 : | ||
| 2521 | // InternalSolverLanguageLexer.g:1:426: If | ||
| 2522 | { | ||
| 2523 | mIf(); | ||
| 2524 | |||
| 2525 | } | ||
| 2526 | break; | ||
| 2527 | case 52 : | ||
| 2528 | // InternalSolverLanguageLexer.g:1:429: In | ||
| 2529 | { | ||
| 2530 | mIn(); | ||
| 2531 | |||
| 2532 | } | ||
| 2533 | break; | ||
| 2534 | case 53 : | ||
| 2535 | // InternalSolverLanguageLexer.g:1:432: ExclamationMark | ||
| 2536 | { | ||
| 2537 | mExclamationMark(); | ||
| 2538 | |||
| 2539 | } | ||
| 2540 | break; | ||
| 2541 | case 54 : | ||
| 2542 | // InternalSolverLanguageLexer.g:1:448: LeftParenthesis | ||
| 2543 | { | ||
| 2544 | mLeftParenthesis(); | ||
| 2545 | |||
| 2546 | } | ||
| 2547 | break; | ||
| 2548 | case 55 : | ||
| 2549 | // InternalSolverLanguageLexer.g:1:464: RightParenthesis | ||
| 2550 | { | ||
| 2551 | mRightParenthesis(); | ||
| 2552 | |||
| 2553 | } | ||
| 2554 | break; | ||
| 2555 | case 56 : | ||
| 2556 | // InternalSolverLanguageLexer.g:1:481: Asterisk | ||
| 2557 | { | ||
| 2558 | mAsterisk(); | ||
| 2559 | |||
| 2560 | } | ||
| 2561 | break; | ||
| 2562 | case 57 : | ||
| 2563 | // InternalSolverLanguageLexer.g:1:490: PlusSign | ||
| 2564 | { | ||
| 2565 | mPlusSign(); | ||
| 2566 | |||
| 2567 | } | ||
| 2568 | break; | ||
| 2569 | case 58 : | ||
| 2570 | // InternalSolverLanguageLexer.g:1:499: Comma | ||
| 2571 | { | ||
| 2572 | mComma(); | ||
| 2573 | |||
| 2574 | } | ||
| 2575 | break; | ||
| 2576 | case 59 : | ||
| 2577 | // InternalSolverLanguageLexer.g:1:505: HyphenMinus | ||
| 2578 | { | ||
| 2579 | mHyphenMinus(); | ||
| 2580 | |||
| 2581 | } | ||
| 2582 | break; | ||
| 2583 | case 60 : | ||
| 2584 | // InternalSolverLanguageLexer.g:1:517: FullStop | ||
| 2585 | { | ||
| 2586 | mFullStop(); | ||
| 2587 | |||
| 2588 | } | ||
| 2589 | break; | ||
| 2590 | case 61 : | ||
| 2591 | // InternalSolverLanguageLexer.g:1:526: Solidus | ||
| 2592 | { | ||
| 2593 | mSolidus(); | ||
| 2594 | |||
| 2595 | } | ||
| 2596 | break; | ||
| 2597 | case 62 : | ||
| 2598 | // InternalSolverLanguageLexer.g:1:534: Colon | ||
| 2599 | { | ||
| 2600 | mColon(); | ||
| 2601 | |||
| 2602 | } | ||
| 2603 | break; | ||
| 2604 | case 63 : | ||
| 2605 | // InternalSolverLanguageLexer.g:1:540: Semicolon | ||
| 2606 | { | ||
| 2607 | mSemicolon(); | ||
| 2608 | |||
| 2609 | } | ||
| 2610 | break; | ||
| 2611 | case 64 : | ||
| 2612 | // InternalSolverLanguageLexer.g:1:550: LessThanSign | ||
| 2613 | { | ||
| 2614 | mLessThanSign(); | ||
| 2615 | |||
| 2616 | } | ||
| 2617 | break; | ||
| 2618 | case 65 : | ||
| 2619 | // InternalSolverLanguageLexer.g:1:563: EqualsSign | ||
| 2620 | { | ||
| 2621 | mEqualsSign(); | ||
| 2622 | |||
| 2623 | } | ||
| 2624 | break; | ||
| 2625 | case 66 : | ||
| 2626 | // InternalSolverLanguageLexer.g:1:574: GreaterThanSign | ||
| 2627 | { | ||
| 2628 | mGreaterThanSign(); | ||
| 2629 | |||
| 2630 | } | ||
| 2631 | break; | ||
| 2632 | case 67 : | ||
| 2633 | // InternalSolverLanguageLexer.g:1:590: LeftSquareBracket | ||
| 2634 | { | ||
| 2635 | mLeftSquareBracket(); | ||
| 2636 | |||
| 2637 | } | ||
| 2638 | break; | ||
| 2639 | case 68 : | ||
| 2640 | // InternalSolverLanguageLexer.g:1:608: RightSquareBracket | ||
| 2641 | { | ||
| 2642 | mRightSquareBracket(); | ||
| 2643 | |||
| 2644 | } | ||
| 2645 | break; | ||
| 2646 | case 69 : | ||
| 2647 | // InternalSolverLanguageLexer.g:1:627: CircumflexAccent | ||
| 2648 | { | ||
| 2649 | mCircumflexAccent(); | ||
| 2650 | |||
| 2651 | } | ||
| 2652 | break; | ||
| 2653 | case 70 : | ||
| 2654 | // InternalSolverLanguageLexer.g:1:644: LeftCurlyBracket | ||
| 2655 | { | ||
| 2656 | mLeftCurlyBracket(); | ||
| 2657 | |||
| 2658 | } | ||
| 2659 | break; | ||
| 2660 | case 71 : | ||
| 2661 | // InternalSolverLanguageLexer.g:1:661: VerticalLine | ||
| 2662 | { | ||
| 2663 | mVerticalLine(); | ||
| 2664 | |||
| 2665 | } | ||
| 2666 | break; | ||
| 2667 | case 72 : | ||
| 2668 | // InternalSolverLanguageLexer.g:1:674: RightCurlyBracket | ||
| 2669 | { | ||
| 2670 | mRightCurlyBracket(); | ||
| 2671 | |||
| 2672 | } | ||
| 2673 | break; | ||
| 2674 | case 73 : | ||
| 2675 | // InternalSolverLanguageLexer.g:1:692: RULE_STRING | ||
| 2676 | { | ||
| 2677 | mRULE_STRING(); | ||
| 2678 | |||
| 2679 | } | ||
| 2680 | break; | ||
| 2681 | case 74 : | ||
| 2682 | // InternalSolverLanguageLexer.g:1:704: RULE_QUOTED_ID | ||
| 2683 | { | ||
| 2684 | mRULE_QUOTED_ID(); | ||
| 2685 | |||
| 2686 | } | ||
| 2687 | break; | ||
| 2688 | case 75 : | ||
| 2689 | // InternalSolverLanguageLexer.g:1:719: RULE_SL_COMMENT | ||
| 2690 | { | ||
| 2691 | mRULE_SL_COMMENT(); | ||
| 2692 | |||
| 2693 | } | ||
| 2694 | break; | ||
| 2695 | case 76 : | ||
| 2696 | // InternalSolverLanguageLexer.g:1:735: RULE_ID | ||
| 2697 | { | ||
| 2698 | mRULE_ID(); | ||
| 2699 | |||
| 2700 | } | ||
| 2701 | break; | ||
| 2702 | case 77 : | ||
| 2703 | // InternalSolverLanguageLexer.g:1:743: RULE_INT | ||
| 2704 | { | ||
| 2705 | mRULE_INT(); | ||
| 2706 | |||
| 2707 | } | ||
| 2708 | break; | ||
| 2709 | case 78 : | ||
| 2710 | // InternalSolverLanguageLexer.g:1:752: RULE_ML_COMMENT | ||
| 2711 | { | ||
| 2712 | mRULE_ML_COMMENT(); | ||
| 2713 | |||
| 2714 | } | ||
| 2715 | break; | ||
| 2716 | case 79 : | ||
| 2717 | // InternalSolverLanguageLexer.g:1:768: RULE_WS | ||
| 2718 | { | ||
| 2719 | mRULE_WS(); | ||
| 2720 | |||
| 2721 | } | ||
| 2722 | break; | ||
| 2723 | case 80 : | ||
| 2724 | // InternalSolverLanguageLexer.g:1:776: RULE_ANY_OTHER | ||
| 2725 | { | ||
| 2726 | mRULE_ANY_OTHER(); | ||
| 2727 | |||
| 2728 | } | ||
| 2729 | break; | ||
| 2730 | |||
| 2731 | } | ||
| 2732 | |||
| 2733 | } | ||
| 2734 | |||
| 2735 | |||
| 2736 | protected DFA12 dfa12 = new DFA12(this); | ||
| 2737 | static final String DFA12_eotS = | ||
| 2738 | "\1\uffff\25\64\1\127\1\131\1\133\1\135\1\137\1\141\1\143\2\64\5\uffff\1\155\3\uffff\1\161\3\uffff\2\62\5\uffff\1\64\1\uffff\37\64\1\u009d\1\u009e\16\uffff\1\u009f\1\u00a0\23\uffff\4\64\1\u00a5\4\64\1\u00ab\1\u00ac\1\u00ae\14\64\1\u00bb\4\64\1\u00c0\1\u00c1\1\u00c2\1\u00c3\1\u00c4\1\u00c5\1\u00c6\4\uffff\4\64\1\uffff\5\64\2\uffff\1\64\1\uffff\1\u00d1\1\64\1\u00d3\1\u00d5\4\64\1\u00db\3\64\1\uffff\1\u00df\1\u00e0\1\u00e1\1\u00e2\7\uffff\2\64\1\u00e5\2\64\1\u00e8\1\64\1\u00ea\2\64\1\uffff\1\64\1\uffff\1\64\1\uffff\3\64\1\u00f2\1\u00f3\1\uffff\2\64\1\u00f6\4\uffff\2\64\1\uffff\2\64\1\uffff\1\64\1\uffff\6\64\1\u0102\2\uffff\1\64\1\u0104\1\uffff\1\u0106\3\64\1\u010a\3\64\1\u010e\1\u010f\1\u0110\1\uffff\1\u0111\1\uffff\1\64\1\uffff\1\64\1\u0114\1\u0115\1\uffff\1\u0116\1\u0117\1\u0118\4\uffff\2\64\5\uffff\1\u011b\1\u011c\2\uffff"; | ||
| 2739 | static final String DFA12_eofS = | ||
| 2740 | "\u011d\uffff"; | ||
| 2741 | static final String DFA12_minS = | ||
| 2742 | "\1\0\1\122\1\141\1\142\1\154\1\141\1\156\1\105\1\145\1\154\1\156\1\117\1\143\1\162\1\145\1\150\1\104\1\111\1\125\1\117\1\125\1\146\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\52\3\uffff\1\101\3\uffff\2\0\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\156\1\162\1\141\1\170\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\60\16\uffff\2\60\23\uffff\1\101\1\143\1\163\1\164\1\60\1\164\1\156\1\162\1\163\3\60\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\60\1\144\1\154\1\156\1\145\7\60\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\60\1\163\2\60\1\165\1\156\1\171\1\162\1\60\1\157\1\105\1\145\1\uffff\4\60\7\uffff\1\105\1\151\1\60\1\141\1\151\1\60\1\156\1\60\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\60\1\uffff\1\167\1\121\1\60\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\60\2\uffff\1\156\1\60\1\uffff\1\60\1\156\1\164\1\163\1\60\3\145\3\60\1\uffff\1\60\1\uffff\1\105\1\uffff\1\141\2\60\1\uffff\3\60\4\uffff\1\121\1\154\5\uffff\2\60\2\uffff"; | ||
| 2743 | static final String DFA12_maxS = | ||
| 2744 | "\1\uffff\1\122\1\165\1\166\2\165\1\160\1\105\1\145\1\170\1\156\1\117\1\165\1\162\1\145\1\162\1\104\1\111\1\125\1\117\1\125\1\156\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\57\3\uffff\1\172\3\uffff\2\uffff\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\165\1\162\1\141\1\171\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\172\16\uffff\2\172\23\uffff\1\101\1\143\1\163\1\164\1\172\1\164\1\156\1\162\1\163\3\172\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\172\1\144\1\154\1\156\1\145\7\172\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\172\1\163\2\172\1\165\1\162\1\171\1\162\1\172\1\157\1\105\1\145\1\uffff\4\172\7\uffff\1\105\1\151\1\172\1\141\1\151\1\172\1\156\1\172\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\172\1\uffff\1\167\1\121\1\172\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\172\2\uffff\1\156\1\172\1\uffff\1\172\1\156\1\164\1\163\1\172\3\145\3\172\1\uffff\1\172\1\uffff\1\105\1\uffff\1\141\2\172\1\uffff\3\172\4\uffff\1\121\1\154\5\uffff\2\172\2\uffff"; | ||
| 2745 | static final String DFA12_acceptS = | ||
| 2746 | "\37\uffff\1\66\1\67\1\70\1\71\1\72\1\uffff\1\77\1\103\1\104\1\uffff\1\106\1\107\1\110\2\uffff\1\113\1\114\1\115\1\117\1\120\1\uffff\1\114\41\uffff\1\52\1\65\1\53\1\73\1\54\1\74\1\55\1\76\1\56\1\100\1\57\1\101\1\60\1\102\2\uffff\1\66\1\67\1\70\1\71\1\72\1\113\1\116\1\75\1\77\1\103\1\104\1\105\1\106\1\107\1\110\1\111\1\112\1\115\1\117\44\uffff\1\64\1\63\1\61\1\62\4\uffff\1\43\5\uffff\1\46\1\47\1\uffff\1\50\14\uffff\1\51\4\uffff\1\36\1\37\1\40\1\41\1\42\1\44\1\45\12\uffff\1\30\1\uffff\1\31\1\uffff\1\26\5\uffff\1\27\3\uffff\1\32\1\33\1\34\1\35\2\uffff\1\24\2\uffff\1\21\1\uffff\1\20\7\uffff\1\22\1\23\2\uffff\1\25\13\uffff\1\17\1\uffff\1\16\1\uffff\1\10\3\uffff\1\12\3\uffff\1\11\1\13\1\14\1\15\2\uffff\1\3\1\4\1\5\1\6\1\7\2\uffff\1\1\1\2"; | ||
| 2747 | static final String DFA12_specialS = | ||
| 2748 | "\1\1\53\uffff\1\0\1\2\u00ef\uffff}>"; | ||
| 2749 | static final String[] DFA12_transitionS = { | ||
| 2750 | "\11\62\2\61\2\62\1\61\22\62\1\61\1\26\1\54\2\62\1\56\1\62\1\55\1\37\1\40\1\41\1\42\1\43\1\27\1\30\1\44\12\60\1\31\1\45\1\32\1\33\1\34\2\62\1\20\2\57\1\21\1\35\1\57\1\1\1\57\1\36\2\57\1\7\1\22\1\13\1\57\1\23\2\57\1\24\7\57\1\46\1\62\1\47\1\50\1\57\1\62\1\3\1\57\1\4\1\10\1\11\1\2\2\57\1\25\3\57\1\5\1\57\1\6\1\15\1\57\1\16\1\14\1\17\1\12\5\57\1\51\1\52\1\53\uff82\62", | ||
| 2751 | "\1\63", | ||
| 2752 | "\1\66\23\uffff\1\65", | ||
| 2753 | "\1\67\23\uffff\1\70", | ||
| 2754 | "\1\73\2\uffff\1\71\5\uffff\1\72", | ||
| 2755 | "\1\74\7\uffff\1\75\13\uffff\1\76", | ||
| 2756 | "\1\100\1\uffff\1\77", | ||
| 2757 | "\1\101", | ||
| 2758 | "\1\102", | ||
| 2759 | "\1\106\1\104\4\uffff\1\105\5\uffff\1\103", | ||
| 2760 | "\1\107", | ||
| 2761 | "\1\110", | ||
| 2762 | "\1\111\21\uffff\1\112", | ||
| 2763 | "\1\113", | ||
| 2764 | "\1\114", | ||
| 2765 | "\1\115\11\uffff\1\116", | ||
| 2766 | "\1\117", | ||
| 2767 | "\1\120", | ||
| 2768 | "\1\121", | ||
| 2769 | "\1\122", | ||
| 2770 | "\1\123", | ||
| 2771 | "\1\125\7\uffff\1\124", | ||
| 2772 | "\1\126", | ||
| 2773 | "\1\130", | ||
| 2774 | "\1\132", | ||
| 2775 | "\1\134", | ||
| 2776 | "\1\136", | ||
| 2777 | "\1\140", | ||
| 2778 | "\1\142", | ||
| 2779 | "\1\144", | ||
| 2780 | "\1\145", | ||
| 2781 | "", | ||
| 2782 | "", | ||
| 2783 | "", | ||
| 2784 | "", | ||
| 2785 | "", | ||
| 2786 | "\1\154\4\uffff\1\153", | ||
| 2787 | "", | ||
| 2788 | "", | ||
| 2789 | "", | ||
| 2790 | "\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2791 | "", | ||
| 2792 | "", | ||
| 2793 | "", | ||
| 2794 | "\0\165", | ||
| 2795 | "\0\166", | ||
| 2796 | "", | ||
| 2797 | "", | ||
| 2798 | "", | ||
| 2799 | "", | ||
| 2800 | "", | ||
| 2801 | "\1\171", | ||
| 2802 | "", | ||
| 2803 | "\1\172", | ||
| 2804 | "\1\173", | ||
| 2805 | "\1\174", | ||
| 2806 | "\1\175", | ||
| 2807 | "\1\176\6\uffff\1\177", | ||
| 2808 | "\1\u0080", | ||
| 2809 | "\1\u0081", | ||
| 2810 | "\1\u0082\1\u0083", | ||
| 2811 | "\1\u0084", | ||
| 2812 | "\1\u0085", | ||
| 2813 | "\1\u0086", | ||
| 2814 | "\1\u0087", | ||
| 2815 | "\1\u0088", | ||
| 2816 | "\1\u0089", | ||
| 2817 | "\1\u008a", | ||
| 2818 | "\1\u008b", | ||
| 2819 | "\1\u008c", | ||
| 2820 | "\1\u008d", | ||
| 2821 | "\1\u008e", | ||
| 2822 | "\1\u008f", | ||
| 2823 | "\1\u0090", | ||
| 2824 | "\1\u0091", | ||
| 2825 | "\1\u0092", | ||
| 2826 | "\1\u0093", | ||
| 2827 | "\1\u0094", | ||
| 2828 | "\1\u0095", | ||
| 2829 | "\1\u0096", | ||
| 2830 | "\1\u0097", | ||
| 2831 | "\1\u0098", | ||
| 2832 | "\1\u0099", | ||
| 2833 | "\1\u009a", | ||
| 2834 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\5\64\1\u009b\15\64\1\u009c\6\64", | ||
| 2835 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2836 | "", | ||
| 2837 | "", | ||
| 2838 | "", | ||
| 2839 | "", | ||
| 2840 | "", | ||
| 2841 | "", | ||
| 2842 | "", | ||
| 2843 | "", | ||
| 2844 | "", | ||
| 2845 | "", | ||
| 2846 | "", | ||
| 2847 | "", | ||
| 2848 | "", | ||
| 2849 | "", | ||
| 2850 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2851 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2852 | "", | ||
| 2853 | "", | ||
| 2854 | "", | ||
| 2855 | "", | ||
| 2856 | "", | ||
| 2857 | "", | ||
| 2858 | "", | ||
| 2859 | "", | ||
| 2860 | "", | ||
| 2861 | "", | ||
| 2862 | "", | ||
| 2863 | "", | ||
| 2864 | "", | ||
| 2865 | "", | ||
| 2866 | "", | ||
| 2867 | "", | ||
| 2868 | "", | ||
| 2869 | "", | ||
| 2870 | "", | ||
| 2871 | "\1\u00a1", | ||
| 2872 | "\1\u00a2", | ||
| 2873 | "\1\u00a3", | ||
| 2874 | "\1\u00a4", | ||
| 2875 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2876 | "\1\u00a6", | ||
| 2877 | "\1\u00a7", | ||
| 2878 | "\1\u00a8", | ||
| 2879 | "\1\u00a9", | ||
| 2880 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00aa\21\64", | ||
| 2881 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2882 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00ad\21\64", | ||
| 2883 | "\1\u00af", | ||
| 2884 | "\1\u00b0", | ||
| 2885 | "\1\u00b1", | ||
| 2886 | "\1\u00b2", | ||
| 2887 | "\1\u00b3", | ||
| 2888 | "\1\u00b4", | ||
| 2889 | "\1\u00b5", | ||
| 2890 | "\1\u00b6", | ||
| 2891 | "\1\u00b7", | ||
| 2892 | "\1\u00b8", | ||
| 2893 | "\1\u00b9", | ||
| 2894 | "\1\u00ba", | ||
| 2895 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2896 | "\1\u00bc", | ||
| 2897 | "\1\u00bd", | ||
| 2898 | "\1\u00be", | ||
| 2899 | "\1\u00bf", | ||
| 2900 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2901 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2902 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2903 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2904 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2905 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2906 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2907 | "", | ||
| 2908 | "", | ||
| 2909 | "", | ||
| 2910 | "", | ||
| 2911 | "\1\u00c7", | ||
| 2912 | "\1\u00c8", | ||
| 2913 | "\1\u00c9", | ||
| 2914 | "\1\u00ca", | ||
| 2915 | "", | ||
| 2916 | "\1\u00cb", | ||
| 2917 | "\1\u00cc", | ||
| 2918 | "\1\u00cd", | ||
| 2919 | "\1\u00ce", | ||
| 2920 | "\1\u00cf", | ||
| 2921 | "", | ||
| 2922 | "", | ||
| 2923 | "\1\u00d0", | ||
| 2924 | "", | ||
| 2925 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2926 | "\1\u00d2", | ||
| 2927 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2928 | "\12\64\7\uffff\32\64\4\uffff\1\u00d4\1\uffff\32\64", | ||
| 2929 | "\1\u00d6", | ||
| 2930 | "\1\u00d7\3\uffff\1\u00d8", | ||
| 2931 | "\1\u00d9", | ||
| 2932 | "\1\u00da", | ||
| 2933 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2934 | "\1\u00dc", | ||
| 2935 | "\1\u00dd", | ||
| 2936 | "\1\u00de", | ||
| 2937 | "", | ||
| 2938 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2939 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2940 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2941 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2942 | "", | ||
| 2943 | "", | ||
| 2944 | "", | ||
| 2945 | "", | ||
| 2946 | "", | ||
| 2947 | "", | ||
| 2948 | "", | ||
| 2949 | "\1\u00e3", | ||
| 2950 | "\1\u00e4", | ||
| 2951 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2952 | "\1\u00e6", | ||
| 2953 | "\1\u00e7", | ||
| 2954 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2955 | "\1\u00e9", | ||
| 2956 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2957 | "\1\u00eb", | ||
| 2958 | "\1\u00ec", | ||
| 2959 | "", | ||
| 2960 | "\1\u00ed", | ||
| 2961 | "", | ||
| 2962 | "\1\u00ee", | ||
| 2963 | "", | ||
| 2964 | "\1\u00ef", | ||
| 2965 | "\1\u00f0", | ||
| 2966 | "\1\u00f1", | ||
| 2967 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2968 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2969 | "", | ||
| 2970 | "\1\u00f4", | ||
| 2971 | "\1\u00f5", | ||
| 2972 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2973 | "", | ||
| 2974 | "", | ||
| 2975 | "", | ||
| 2976 | "", | ||
| 2977 | "\1\u00f7", | ||
| 2978 | "\1\u00f8", | ||
| 2979 | "", | ||
| 2980 | "\1\u00f9", | ||
| 2981 | "\1\u00fa", | ||
| 2982 | "", | ||
| 2983 | "\1\u00fb", | ||
| 2984 | "", | ||
| 2985 | "\1\u00fc", | ||
| 2986 | "\1\u00fd", | ||
| 2987 | "\1\u00fe", | ||
| 2988 | "\1\u00ff", | ||
| 2989 | "\1\u0100", | ||
| 2990 | "\1\u0101", | ||
| 2991 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2992 | "", | ||
| 2993 | "", | ||
| 2994 | "\1\u0103", | ||
| 2995 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 2996 | "", | ||
| 2997 | "\12\64\7\uffff\32\64\4\uffff\1\u0105\1\uffff\32\64", | ||
| 2998 | "\1\u0107", | ||
| 2999 | "\1\u0108", | ||
| 3000 | "\1\u0109", | ||
| 3001 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3002 | "\1\u010b", | ||
| 3003 | "\1\u010c", | ||
| 3004 | "\1\u010d", | ||
| 3005 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3006 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3007 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3008 | "", | ||
| 3009 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3010 | "", | ||
| 3011 | "\1\u0112", | ||
| 3012 | "", | ||
| 3013 | "\1\u0113", | ||
| 3014 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3015 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3016 | "", | ||
| 3017 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3018 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3019 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3020 | "", | ||
| 3021 | "", | ||
| 3022 | "", | ||
| 3023 | "", | ||
| 3024 | "\1\u0119", | ||
| 3025 | "\1\u011a", | ||
| 3026 | "", | ||
| 3027 | "", | ||
| 3028 | "", | ||
| 3029 | "", | ||
| 3030 | "", | ||
| 3031 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3032 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
| 3033 | "", | ||
| 3034 | "" | ||
| 3035 | }; | ||
| 3036 | |||
| 3037 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | ||
| 3038 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | ||
| 3039 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | ||
| 3040 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | ||
| 3041 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | ||
| 3042 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | ||
| 3043 | static final short[][] DFA12_transition; | ||
| 3044 | |||
| 3045 | static { | ||
| 3046 | int numStates = DFA12_transitionS.length; | ||
| 3047 | DFA12_transition = new short[numStates][]; | ||
| 3048 | for (int i=0; i<numStates; i++) { | ||
| 3049 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | ||
| 3050 | } | ||
| 3051 | } | ||
| 3052 | |||
| 3053 | class DFA12 extends DFA { | ||
| 3054 | |||
| 3055 | public DFA12(BaseRecognizer recognizer) { | ||
| 3056 | this.recognizer = recognizer; | ||
| 3057 | this.decisionNumber = 12; | ||
| 3058 | this.eot = DFA12_eot; | ||
| 3059 | this.eof = DFA12_eof; | ||
| 3060 | this.min = DFA12_min; | ||
| 3061 | this.max = DFA12_max; | ||
| 3062 | this.accept = DFA12_accept; | ||
| 3063 | this.special = DFA12_special; | ||
| 3064 | this.transition = DFA12_transition; | ||
| 3065 | } | ||
| 3066 | public String getDescription() { | ||
| 3067 | return "1:1: Tokens : ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
| 3068 | } | ||
| 3069 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
| 3070 | IntStream input = _input; | ||
| 3071 | int _s = s; | ||
| 3072 | switch ( s ) { | ||
| 3073 | case 0 : | ||
| 3074 | int LA12_44 = input.LA(1); | ||
| 3075 | |||
| 3076 | s = -1; | ||
| 3077 | if ( ((LA12_44>='\u0000' && LA12_44<='\uFFFF')) ) {s = 117;} | ||
| 3078 | |||
| 3079 | else s = 50; | ||
| 3080 | |||
| 3081 | if ( s>=0 ) return s; | ||
| 3082 | break; | ||
| 3083 | case 1 : | ||
| 3084 | int LA12_0 = input.LA(1); | ||
| 3085 | |||
| 3086 | s = -1; | ||
| 3087 | if ( (LA12_0=='G') ) {s = 1;} | ||
| 3088 | |||
| 3089 | else if ( (LA12_0=='f') ) {s = 2;} | ||
| 3090 | |||
| 3091 | else if ( (LA12_0=='a') ) {s = 3;} | ||
| 3092 | |||
| 3093 | else if ( (LA12_0=='c') ) {s = 4;} | ||
| 3094 | |||
| 3095 | else if ( (LA12_0=='m') ) {s = 5;} | ||
| 3096 | |||
| 3097 | else if ( (LA12_0=='o') ) {s = 6;} | ||
| 3098 | |||
| 3099 | else if ( (LA12_0=='L') ) {s = 7;} | ||
| 3100 | |||
| 3101 | else if ( (LA12_0=='d') ) {s = 8;} | ||
| 3102 | |||
| 3103 | else if ( (LA12_0=='e') ) {s = 9;} | ||
| 3104 | |||
| 3105 | else if ( (LA12_0=='u') ) {s = 10;} | ||
| 3106 | |||
| 3107 | else if ( (LA12_0=='N') ) {s = 11;} | ||
| 3108 | |||
| 3109 | else if ( (LA12_0=='s') ) {s = 12;} | ||
| 3110 | |||
| 3111 | else if ( (LA12_0=='p') ) {s = 13;} | ||
| 3112 | |||
| 3113 | else if ( (LA12_0=='r') ) {s = 14;} | ||
| 3114 | |||
| 3115 | else if ( (LA12_0=='t') ) {s = 15;} | ||
| 3116 | |||
| 3117 | else if ( (LA12_0=='A') ) {s = 16;} | ||
| 3118 | |||
| 3119 | else if ( (LA12_0=='D') ) {s = 17;} | ||
| 3120 | |||
| 3121 | else if ( (LA12_0=='M') ) {s = 18;} | ||
| 3122 | |||
| 3123 | else if ( (LA12_0=='P') ) {s = 19;} | ||
| 3124 | |||
| 3125 | else if ( (LA12_0=='S') ) {s = 20;} | ||
| 3126 | |||
| 3127 | else if ( (LA12_0=='i') ) {s = 21;} | ||
| 3128 | |||
| 3129 | else if ( (LA12_0=='!') ) {s = 22;} | ||
| 3130 | |||
| 3131 | else if ( (LA12_0=='-') ) {s = 23;} | ||
| 3132 | |||
| 3133 | else if ( (LA12_0=='.') ) {s = 24;} | ||
| 3134 | |||
| 3135 | else if ( (LA12_0==':') ) {s = 25;} | ||
| 3136 | |||
| 3137 | else if ( (LA12_0=='<') ) {s = 26;} | ||
| 3138 | |||
| 3139 | else if ( (LA12_0=='=') ) {s = 27;} | ||
| 3140 | |||
| 3141 | else if ( (LA12_0=='>') ) {s = 28;} | ||
| 3142 | |||
| 3143 | else if ( (LA12_0=='E') ) {s = 29;} | ||
| 3144 | |||
| 3145 | else if ( (LA12_0=='I') ) {s = 30;} | ||
| 3146 | |||
| 3147 | else if ( (LA12_0=='(') ) {s = 31;} | ||
| 3148 | |||
| 3149 | else if ( (LA12_0==')') ) {s = 32;} | ||
| 3150 | |||
| 3151 | else if ( (LA12_0=='*') ) {s = 33;} | ||
| 3152 | |||
| 3153 | else if ( (LA12_0=='+') ) {s = 34;} | ||
| 3154 | |||
| 3155 | else if ( (LA12_0==',') ) {s = 35;} | ||
| 3156 | |||
| 3157 | else if ( (LA12_0=='/') ) {s = 36;} | ||
| 3158 | |||
| 3159 | else if ( (LA12_0==';') ) {s = 37;} | ||
| 3160 | |||
| 3161 | else if ( (LA12_0=='[') ) {s = 38;} | ||
| 3162 | |||
| 3163 | else if ( (LA12_0==']') ) {s = 39;} | ||
| 3164 | |||
| 3165 | else if ( (LA12_0=='^') ) {s = 40;} | ||
| 3166 | |||
| 3167 | else if ( (LA12_0=='{') ) {s = 41;} | ||
| 3168 | |||
| 3169 | else if ( (LA12_0=='|') ) {s = 42;} | ||
| 3170 | |||
| 3171 | else if ( (LA12_0=='}') ) {s = 43;} | ||
| 3172 | |||
| 3173 | else if ( (LA12_0=='\"') ) {s = 44;} | ||
| 3174 | |||
| 3175 | else if ( (LA12_0=='\'') ) {s = 45;} | ||
| 3176 | |||
| 3177 | else if ( (LA12_0=='%') ) {s = 46;} | ||
| 3178 | |||
| 3179 | else if ( ((LA12_0>='B' && LA12_0<='C')||LA12_0=='F'||LA12_0=='H'||(LA12_0>='J' && LA12_0<='K')||LA12_0=='O'||(LA12_0>='Q' && LA12_0<='R')||(LA12_0>='T' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||(LA12_0>='g' && LA12_0<='h')||(LA12_0>='j' && LA12_0<='l')||LA12_0=='n'||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 47;} | ||
| 3180 | |||
| 3181 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 48;} | ||
| 3182 | |||
| 3183 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 49;} | ||
| 3184 | |||
| 3185 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||(LA12_0>='?' && LA12_0<='@')||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 50;} | ||
| 3186 | |||
| 3187 | if ( s>=0 ) return s; | ||
| 3188 | break; | ||
| 3189 | case 2 : | ||
| 3190 | int LA12_45 = input.LA(1); | ||
| 3191 | |||
| 3192 | s = -1; | ||
| 3193 | if ( ((LA12_45>='\u0000' && LA12_45<='\uFFFF')) ) {s = 118;} | ||
| 3194 | |||
| 3195 | else s = 50; | ||
| 3196 | |||
| 3197 | if ( s>=0 ) return s; | ||
| 3198 | break; | ||
| 3199 | } | ||
| 3200 | NoViableAltException nvae = | ||
| 3201 | new NoViableAltException(getDescription(), 12, _s, input); | ||
| 3202 | error(nvae); | ||
| 3203 | throw nvae; | ||
| 3204 | } | ||
| 3205 | } | ||
| 3206 | |||
| 3207 | |||
| 3208 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens new file mode 100644 index 00000000..133cc9d6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens | |||
| @@ -0,0 +1,83 @@ | |||
| 1 | ADD=33 | ||
| 2 | Abstract=6 | ||
| 3 | Asterisk=59 | ||
| 4 | Avg=38 | ||
| 5 | CircumflexAccent=72 | ||
| 6 | Class=19 | ||
| 7 | Colon=65 | ||
| 8 | ColonHyphenMinus=48 | ||
| 9 | Comma=61 | ||
| 10 | Contains=7 | ||
| 11 | Count=20 | ||
| 12 | Current=13 | ||
| 13 | DIV=34 | ||
| 14 | Default=14 | ||
| 15 | EQ=52 | ||
| 16 | Else=26 | ||
| 17 | Empty=21 | ||
| 18 | EqualsSign=68 | ||
| 19 | EqualsSignEqualsSign=50 | ||
| 20 | Error=22 | ||
| 21 | ExclamationMark=56 | ||
| 22 | ExclamationMarkEqualsSign=45 | ||
| 23 | Extends=15 | ||
| 24 | Extern=18 | ||
| 25 | False=23 | ||
| 26 | FullStop=63 | ||
| 27 | FullStopFullStop=47 | ||
| 28 | Functional=5 | ||
| 29 | GREATER=11 | ||
| 30 | GREATER_EQ=4 | ||
| 31 | GreaterThanSign=69 | ||
| 32 | GreaterThanSignEqualsSign=51 | ||
| 33 | HyphenMinus=62 | ||
| 34 | HyphenMinusGreaterThanSign=46 | ||
| 35 | IN=53 | ||
| 36 | If=54 | ||
| 37 | In=55 | ||
| 38 | Inf=39 | ||
| 39 | Int=40 | ||
| 40 | LESS=25 | ||
| 41 | LESS_EQ=12 | ||
| 42 | LeftCurlyBracket=73 | ||
| 43 | LeftParenthesis=57 | ||
| 44 | LeftSquareBracket=70 | ||
| 45 | LessThanSign=67 | ||
| 46 | LessThanSignEqualsSign=49 | ||
| 47 | MUL=35 | ||
| 48 | Max=41 | ||
| 49 | Maximize=8 | ||
| 50 | May=42 | ||
| 51 | Min=43 | ||
| 52 | Minimize=9 | ||
| 53 | Must=27 | ||
| 54 | NOT_EQ=17 | ||
| 55 | Only=28 | ||
| 56 | Opposite=10 | ||
| 57 | POW=36 | ||
| 58 | PlusSign=60 | ||
| 59 | Prod=29 | ||
| 60 | RULE_ANY_OTHER=86 | ||
| 61 | RULE_FULL_STOP=81 | ||
| 62 | RULE_ID=82 | ||
| 63 | RULE_INT=83 | ||
| 64 | RULE_ML_COMMENT=84 | ||
| 65 | RULE_QUOTED_ID=77 | ||
| 66 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80 | ||
| 67 | RULE_SL_COMMENT=78 | ||
| 68 | RULE_STRING=76 | ||
| 69 | RULE_TRANSITIVE_CLOSURE=79 | ||
| 70 | RULE_WS=85 | ||
| 71 | Real=30 | ||
| 72 | RightCurlyBracket=75 | ||
| 73 | RightParenthesis=58 | ||
| 74 | RightSquareBracket=71 | ||
| 75 | SUB=37 | ||
| 76 | Scope=24 | ||
| 77 | Semicolon=66 | ||
| 78 | Solidus=64 | ||
| 79 | Sum=44 | ||
| 80 | Then=31 | ||
| 81 | True=32 | ||
| 82 | Unknown=16 | ||
| 83 | VerticalLine=74 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java index 52cb01b5..fabd22c7 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.scoping; | 4 | package org.eclipse.viatra.solver.language.scoping; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java index 1ad39fd7..5cb73796 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.serializer; | 4 | package org.eclipse.viatra.solver.language.serializer; |
| 5 | 5 | ||
| @@ -8,43 +8,48 @@ import java.util.Set; | |||
| 8 | import org.eclipse.emf.ecore.EObject; | 8 | import org.eclipse.emf.ecore.EObject; |
| 9 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
| 10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | 10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; |
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; |
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; |
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; |
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; |
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition; |
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | 17 | import org.eclipse.viatra.solver.language.solverLanguage.Call; |
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | 18 | import org.eclipse.viatra.solver.language.solverLanguage.Case; |
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | 19 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition; |
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | 20 | import org.eclipse.viatra.solver.language.solverLanguage.Comparison; |
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | 21 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; |
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | 22 | import org.eclipse.viatra.solver.language.solverLanguage.Count; |
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | 23 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition; |
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.False; | 24 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; |
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | 25 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral; |
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | 26 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; |
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | 27 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition; |
| 28 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | 28 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; |
| 29 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | 29 | import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition; |
| 30 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | 30 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition; |
| 31 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | 31 | import org.eclipse.viatra.solver.language.solverLanguage.IfElse; |
| 32 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | 32 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; |
| 33 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | 33 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; |
| 34 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | 34 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; |
| 35 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | 35 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition; |
| 36 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | 36 | import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity; |
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; | ||
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition; | ||
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral; | ||
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition; | ||
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | ||
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | 43 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; |
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | 44 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; |
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 45 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | 46 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; |
| 43 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | 47 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; |
| 44 | import org.eclipse.viatra.solver.language.solverLanguage.True; | 48 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; |
| 45 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | 49 | import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument; |
| 46 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | 50 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; |
| 47 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | 51 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; |
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition; | ||
| 48 | import org.eclipse.xtext.Action; | 53 | import org.eclipse.xtext.Action; |
| 49 | import org.eclipse.xtext.Parameter; | 54 | import org.eclipse.xtext.Parameter; |
| 50 | import org.eclipse.xtext.ParserRule; | 55 | import org.eclipse.xtext.ParserRule; |
| @@ -67,119 +72,157 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
| 67 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); | 72 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); |
| 68 | if (epackage == SolverLanguagePackage.eINSTANCE) | 73 | if (epackage == SolverLanguagePackage.eINSTANCE) |
| 69 | switch (semanticObject.eClass().getClassifierID()) { | 74 | switch (semanticObject.eClass().getClassifierID()) { |
| 70 | case SolverLanguagePackage.ALL_INSTANCES: | 75 | case SolverLanguagePackage.AGGREGATION: |
| 71 | sequence_AllInstances(context, (AllInstances) semanticObject); | 76 | sequence_Aggregation(context, (Aggregation) semanticObject); |
| 72 | return; | 77 | return; |
| 73 | case SolverLanguagePackage.ALL_OBJECTS: | 78 | case SolverLanguagePackage.ARGUMENT_LIST: |
| 74 | sequence_AllObjects(context, (AllObjects) semanticObject); | 79 | sequence_ArgumentList(context, (ArgumentList) semanticObject); |
| 75 | return; | 80 | return; |
| 76 | case SolverLanguagePackage.BASIC_INTERPRETATION: | 81 | case SolverLanguagePackage.ASSERTION: |
| 77 | sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject); | 82 | sequence_AssertionOrDefinition(context, (Assertion) semanticObject); |
| 78 | return; | 83 | return; |
| 79 | case SolverLanguagePackage.BOOLEAN_FALSE: | 84 | case SolverLanguagePackage.BINARY_EXPRESSION: |
| 80 | sequence_BooleanValue(context, (BooleanFalse) semanticObject); | 85 | sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject); |
| 81 | return; | 86 | return; |
| 82 | case SolverLanguagePackage.BOOLEAN_OBJECT: | 87 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: |
| 83 | sequence_BooleanObject(context, (BooleanObject) semanticObject); | 88 | sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject); |
| 84 | return; | 89 | return; |
| 85 | case SolverLanguagePackage.BOOLEAN_SYMBOL: | 90 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: |
| 86 | sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject); | 91 | sequence_BoundedScopeDefinition(context, (BoundedScopeDefinition) semanticObject); |
| 87 | return; | 92 | return; |
| 88 | case SolverLanguagePackage.BOOLEAN_TRUE: | 93 | case SolverLanguagePackage.CALL: |
| 89 | sequence_BooleanValue(context, (BooleanTrue) semanticObject); | 94 | sequence_Call(context, (Call) semanticObject); |
| 90 | return; | 95 | return; |
| 91 | case SolverLanguagePackage.CLASS_INTERPRETATION: | 96 | case SolverLanguagePackage.CASE: |
| 92 | sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject); | 97 | if (rule == grammarAccess.getCaseRule()) { |
| 98 | sequence_Case(context, (Case) semanticObject); | ||
| 99 | return; | ||
| 100 | } | ||
| 101 | else if (action == grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()) { | ||
| 102 | sequence_DisjunctiveExpression_Switch_1_1_3(context, (Case) semanticObject); | ||
| 103 | return; | ||
| 104 | } | ||
| 105 | else break; | ||
| 106 | case SolverLanguagePackage.CLASS_DEFINITION: | ||
| 107 | sequence_ClassDefinition(context, (ClassDefinition) semanticObject); | ||
| 93 | return; | 108 | return; |
| 94 | case SolverLanguagePackage.CONSTRAINT: | 109 | case SolverLanguagePackage.COMPARISON: |
| 95 | sequence_Constraint(context, (Constraint) semanticObject); | 110 | sequence_ComparisonExpression(context, (Comparison) semanticObject); |
| 96 | return; | 111 | return; |
| 97 | case SolverLanguagePackage.DEFAULT_INTERPRETATION: | 112 | case SolverLanguagePackage.CONJUNCTION: |
| 98 | sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject); | 113 | sequence_ConjunctiveExpression(context, (Conjunction) semanticObject); |
| 99 | return; | 114 | return; |
| 100 | case SolverLanguagePackage.ENUM_INTERPRETATION: | 115 | case SolverLanguagePackage.COUNT: |
| 101 | sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject); | 116 | sequence_Count(context, (Count) semanticObject); |
| 102 | return; | 117 | return; |
| 103 | case SolverLanguagePackage.EQUALS_SYMBOL: | 118 | case SolverLanguagePackage.DEFAULT_DEFINITION: |
| 104 | sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject); | 119 | sequence_DefaultDefinition(context, (DefaultDefinition) semanticObject); |
| 105 | return; | 120 | return; |
| 106 | case SolverLanguagePackage.ERROR: | 121 | case SolverLanguagePackage.DISJUNCTION: |
| 107 | sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject); | 122 | sequence_DisjunctiveExpression(context, (Disjunction) semanticObject); |
| 108 | return; | 123 | return; |
| 109 | case SolverLanguagePackage.EXIST_SYMBOL: | 124 | case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: |
| 110 | sequence_ExistSymbol(context, (ExistSymbol) semanticObject); | 125 | sequence_EmptyIntervalLiteral(context, (EmptyIntervalLiteral) semanticObject); |
| 111 | return; | 126 | return; |
| 112 | case SolverLanguagePackage.FALSE: | 127 | case SolverLanguagePackage.EXACT_MULTIPLICITY: |
| 113 | sequence_TruthValue(context, (False) semanticObject); | 128 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); |
| 114 | return; | 129 | return; |
| 115 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: | 130 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: |
| 116 | sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject); | 131 | sequence_ExactScopeDefinition(context, (ExactScopeDefinition) semanticObject); |
| 117 | return; | 132 | return; |
| 118 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: | 133 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: |
| 119 | sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject); | 134 | sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject); |
| 120 | return; | 135 | return; |
| 121 | case SolverLanguagePackage.INT_OBJECT: | 136 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: |
| 122 | sequence_IntObject(context, (IntObject) semanticObject); | 137 | sequence_ExternMetricDefinition(context, (ExternMetricDefinition) semanticObject); |
| 123 | return; | 138 | return; |
| 124 | case SolverLanguagePackage.INTEGER_SYMBOL: | 139 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: |
| 125 | sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject); | 140 | sequence_ExternPredicateDefinition(context, (ExternPredicateDefinition) semanticObject); |
| 126 | return; | 141 | return; |
| 127 | case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: | 142 | case SolverLanguagePackage.IF_ELSE: |
| 128 | sequence_ClosureType(context, (IrreflexiveClosure) semanticObject); | 143 | sequence_IfElse(context, (IfElse) semanticObject); |
| 129 | return; | 144 | return; |
| 130 | case SolverLanguagePackage.MODEL_SYMBOL: | 145 | case SolverLanguagePackage.INFINITY_LITERAL: |
| 131 | sequence_ModelSymbol(context, (ModelSymbol) semanticObject); | 146 | sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject); |
| 132 | return; | 147 | return; |
| 133 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION: | 148 | case SolverLanguagePackage.INTERVAL: |
| 134 | sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject); | 149 | sequence_Interval(context, (Interval) semanticObject); |
| 135 | return; | 150 | return; |
| 136 | case SolverLanguagePackage.NAMED_OBJECT: | 151 | case SolverLanguagePackage.LOGIC_LITERAL: |
| 137 | sequence_NamedObject(context, (NamedObject) semanticObject); | 152 | sequence_LogicLiteral(context, (LogicLiteral) semanticObject); |
| 138 | return; | 153 | return; |
| 139 | case SolverLanguagePackage.NEGATIVE: | 154 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: |
| 140 | sequence_Polarity(context, (Negative) semanticObject); | 155 | sequence_LowerBoundedScopeDefinition(context, (LowerBoundedScopeDefinition) semanticObject); |
| 141 | return; | 156 | return; |
| 142 | case SolverLanguagePackage.PARAMETER: | 157 | case SolverLanguagePackage.MANY_MULTIPLICITY: |
| 143 | sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject); | 158 | sequence_ManyMultiplicity(context, (ManyMultiplicity) semanticObject); |
| 144 | return; | 159 | return; |
| 145 | case SolverLanguagePackage.PATTERN_BODY: | 160 | case SolverLanguagePackage.MEMBER_DEFINITION: |
| 146 | sequence_PatternBody(context, (PatternBody) semanticObject); | 161 | sequence_MemberDefinition(context, (MemberDefinition) semanticObject); |
| 147 | return; | 162 | return; |
| 148 | case SolverLanguagePackage.POSITIVE: | 163 | case SolverLanguagePackage.METRIC_DEFINITION: |
| 149 | sequence_Polarity(context, (Positive) semanticObject); | 164 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { |
| 165 | sequence_AssertionOrDefinition(context, (MetricDefinition) semanticObject); | ||
| 166 | return; | ||
| 167 | } | ||
| 168 | else if (rule == grammarAccess.getStatementRule()) { | ||
| 169 | sequence_AssertionOrDefinition_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
| 170 | return; | ||
| 171 | } | ||
| 172 | else if (rule == grammarAccess.getMetricDefinitionRule()) { | ||
| 173 | sequence_MetricDefinition(context, (MetricDefinition) semanticObject); | ||
| 174 | return; | ||
| 175 | } | ||
| 176 | else break; | ||
| 177 | case SolverLanguagePackage.NAMED_ELEMENT: | ||
| 178 | sequence_NamedElement(context, (NamedElement) semanticObject); | ||
| 150 | return; | 179 | return; |
| 151 | case SolverLanguagePackage.PREDICATE: | 180 | case SolverLanguagePackage.NUMERIC_LITERAL: |
| 152 | sequence_Predicate(context, (Predicate) semanticObject); | 181 | sequence_NumericLiteral(context, (NumericLiteral) semanticObject); |
| 153 | return; | 182 | return; |
| 183 | case SolverLanguagePackage.OBJECTIVE_DEFINITION: | ||
| 184 | sequence_ObjectiveDefinition(context, (ObjectiveDefinition) semanticObject); | ||
| 185 | return; | ||
| 186 | case SolverLanguagePackage.PREDICATE_DEFINITION: | ||
| 187 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | ||
| 188 | sequence_AssertionOrDefinition(context, (PredicateDefinition) semanticObject); | ||
| 189 | return; | ||
| 190 | } | ||
| 191 | else if (rule == grammarAccess.getStatementRule()) { | ||
| 192 | sequence_AssertionOrDefinition_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
| 193 | return; | ||
| 194 | } | ||
| 195 | else if (rule == grammarAccess.getPredicateDefinitionRule()) { | ||
| 196 | sequence_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
| 197 | return; | ||
| 198 | } | ||
| 199 | else break; | ||
| 154 | case SolverLanguagePackage.PROBLEM: | 200 | case SolverLanguagePackage.PROBLEM: |
| 155 | sequence_Problem(context, (Problem) semanticObject); | 201 | sequence_Problem(context, (Problem) semanticObject); |
| 156 | return; | 202 | return; |
| 157 | case SolverLanguagePackage.REAL_OBJECT: | 203 | case SolverLanguagePackage.REFERENCE: |
| 158 | sequence_RealObject(context, (RealObject) semanticObject); | 204 | sequence_Reference(context, (Reference) semanticObject); |
| 159 | return; | ||
| 160 | case SolverLanguagePackage.REAL_SYMBOL: | ||
| 161 | sequence_RealSymbol(context, (RealSymbol) semanticObject); | ||
| 162 | return; | 205 | return; |
| 163 | case SolverLanguagePackage.REFLEXIVE_CLOSURE: | 206 | case SolverLanguagePackage.STAR_ARGUMENT: |
| 164 | sequence_ClosureType(context, (ReflexiveClosure) semanticObject); | 207 | sequence_StarArgument(context, (StarArgument) semanticObject); |
| 165 | return; | 208 | return; |
| 166 | case SolverLanguagePackage.STRING_OBJECT: | 209 | case SolverLanguagePackage.STRING_LITERAL: |
| 167 | sequence_StringObject(context, (StringObject) semanticObject); | 210 | sequence_StringLiteral(context, (StringLiteral) semanticObject); |
| 168 | return; | 211 | return; |
| 169 | case SolverLanguagePackage.STRING_SYMBOL: | 212 | case SolverLanguagePackage.SWITCH: |
| 170 | sequence_StringSymbol(context, (StringSymbol) semanticObject); | 213 | sequence_DisjunctiveExpression(context, (Switch) semanticObject); |
| 171 | return; | 214 | return; |
| 172 | case SolverLanguagePackage.TRUE: | 215 | case SolverLanguagePackage.TYPED_ARGUMENT: |
| 173 | sequence_TruthValue(context, (True) semanticObject); | 216 | sequence_TypedArgument(context, (TypedArgument) semanticObject); |
| 174 | return; | 217 | return; |
| 175 | case SolverLanguagePackage.UNKNOWN: | 218 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: |
| 176 | sequence_TruthValue(context, (Unknown) semanticObject); | 219 | sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject); |
| 177 | return; | 220 | return; |
| 178 | case SolverLanguagePackage.UNNAMED_OBJECT: | 221 | case SolverLanguagePackage.UNARY_EXPRESSION: |
| 179 | sequence_UnnamedObject(context, (UnnamedObject) semanticObject); | 222 | sequence_UnaryExpression(context, (UnaryExpression) semanticObject); |
| 180 | return; | 223 | return; |
| 181 | case SolverLanguagePackage.VARIABLE: | 224 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: |
| 182 | sequence_Variable(context, (Variable) semanticObject); | 225 | sequence_UnnamedErrorPrediateDefinition(context, (UnnamedErrorPrediateDefinition) semanticObject); |
| 183 | return; | 226 | return; |
| 184 | } | 227 | } |
| 185 | if (errorAcceptor != null) | 228 | if (errorAcceptor != null) |
| @@ -188,574 +231,1152 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS | |||
| 188 | 231 | ||
| 189 | /** | 232 | /** |
| 190 | * Contexts: | 233 | * Contexts: |
| 191 | * ComplexObject returns AllInstances | 234 | * AssertionOrDefinition.Assertion_1_0_0 returns BinaryExpression |
| 192 | * AllInstances returns AllInstances | 235 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression |
| 236 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns BinaryExpression | ||
| 237 | * Expression returns BinaryExpression | ||
| 238 | * DisjunctiveExpression returns BinaryExpression | ||
| 239 | * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression | ||
| 240 | * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression | ||
| 241 | * ConjunctiveExpression returns BinaryExpression | ||
| 242 | * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression | ||
| 243 | * ComparisonExpression returns BinaryExpression | ||
| 244 | * ComparisonExpression.Comparison_1_0 returns BinaryExpression | ||
| 245 | * AdditiveExpression returns BinaryExpression | ||
| 246 | * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression | ||
| 247 | * MultiplicativeExpression returns BinaryExpression | ||
| 248 | * MultiplicativeExpression.BinaryExpression_1_0 returns BinaryExpression | ||
| 249 | * ExponentialExpression returns BinaryExpression | ||
| 250 | * ExponentialExpression.BinaryExpression_1_0 returns BinaryExpression | ||
| 251 | * UnaryExpression returns BinaryExpression | ||
| 252 | * AggregationExpression returns BinaryExpression | ||
| 253 | * AtomicExpression returns BinaryExpression | ||
| 193 | * | 254 | * |
| 194 | * Constraint: | 255 | * Constraint: |
| 195 | * symbol=Symbol | 256 | * ( |
| 257 | * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) | | ||
| 258 | * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) | | ||
| 259 | * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=ExponentialExpression) | ||
| 260 | * ) | ||
| 196 | */ | 261 | */ |
| 197 | protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) { | 262 | protected void sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) { |
| 263 | genericSequencer.createSequence(context, semanticObject); | ||
| 264 | } | ||
| 265 | |||
| 266 | |||
| 267 | /** | ||
| 268 | * Contexts: | ||
| 269 | * AssertionOrDefinition.Assertion_1_0_0 returns Aggregation | ||
| 270 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation | ||
| 271 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Aggregation | ||
| 272 | * Expression returns Aggregation | ||
| 273 | * DisjunctiveExpression returns Aggregation | ||
| 274 | * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation | ||
| 275 | * DisjunctiveExpression.Case_1_1_0 returns Aggregation | ||
| 276 | * ConjunctiveExpression returns Aggregation | ||
| 277 | * ConjunctiveExpression.Conjunction_1_0 returns Aggregation | ||
| 278 | * ComparisonExpression returns Aggregation | ||
| 279 | * ComparisonExpression.Comparison_1_0 returns Aggregation | ||
| 280 | * AdditiveExpression returns Aggregation | ||
| 281 | * AdditiveExpression.BinaryExpression_1_0 returns Aggregation | ||
| 282 | * MultiplicativeExpression returns Aggregation | ||
| 283 | * MultiplicativeExpression.BinaryExpression_1_0 returns Aggregation | ||
| 284 | * ExponentialExpression returns Aggregation | ||
| 285 | * ExponentialExpression.BinaryExpression_1_0 returns Aggregation | ||
| 286 | * UnaryExpression returns Aggregation | ||
| 287 | * AggregationExpression returns Aggregation | ||
| 288 | * Aggregation returns Aggregation | ||
| 289 | * AtomicExpression returns Aggregation | ||
| 290 | * | ||
| 291 | * Constraint: | ||
| 292 | * (op=AggregationOp body=Expression condition=Expression) | ||
| 293 | */ | ||
| 294 | protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) { | ||
| 198 | if (errorAcceptor != null) { | 295 | if (errorAcceptor != null) { |
| 199 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES) | 296 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP) == ValueTransient.YES) |
| 200 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL)); | 297 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP)); |
| 298 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY) == ValueTransient.YES) | ||
| 299 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY)); | ||
| 300 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION) == ValueTransient.YES) | ||
| 301 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION)); | ||
| 201 | } | 302 | } |
| 202 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 303 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 203 | feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol()); | 304 | feeder.accept(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0(), semanticObject.getOp()); |
| 305 | feeder.accept(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
| 306 | feeder.accept(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0(), semanticObject.getCondition()); | ||
| 204 | feeder.finish(); | 307 | feeder.finish(); |
| 205 | } | 308 | } |
| 206 | 309 | ||
| 207 | 310 | ||
| 208 | /** | 311 | /** |
| 209 | * Contexts: | 312 | * Contexts: |
| 210 | * ComplexObject returns AllObjects | 313 | * ArgumentList returns ArgumentList |
| 211 | * AllObjects returns AllObjects | ||
| 212 | * | 314 | * |
| 213 | * Constraint: | 315 | * Constraint: |
| 214 | * {AllObjects} | 316 | * (arguments+=Argument arguments+=Argument*)? |
| 215 | */ | 317 | */ |
| 216 | protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) { | 318 | protected void sequence_ArgumentList(ISerializationContext context, ArgumentList semanticObject) { |
| 217 | genericSequencer.createSequence(context, semanticObject); | 319 | genericSequencer.createSequence(context, semanticObject); |
| 218 | } | 320 | } |
| 219 | 321 | ||
| 220 | 322 | ||
| 221 | /** | 323 | /** |
| 222 | * Contexts: | 324 | * Contexts: |
| 223 | * Statement returns BasicInterpretation | 325 | * Statement returns Assertion |
| 224 | * Interpretation returns BasicInterpretation | 326 | * AssertionOrDefinition returns Assertion |
| 225 | * BasicInterpretation returns BasicInterpretation | ||
| 226 | * | 327 | * |
| 227 | * Constraint: | 328 | * Constraint: |
| 228 | * (symbol=Symbol (objects+=ComplexObject objects+=ComplexObject*)? value=TruthValue) | 329 | * (body=AssertionOrDefinition_Assertion_1_0_0 range=Expression?) |
| 229 | */ | 330 | */ |
| 230 | protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) { | 331 | protected void sequence_AssertionOrDefinition(ISerializationContext context, Assertion semanticObject) { |
| 231 | genericSequencer.createSequence(context, semanticObject); | 332 | genericSequencer.createSequence(context, semanticObject); |
| 232 | } | 333 | } |
| 233 | 334 | ||
| 234 | 335 | ||
| 235 | /** | 336 | /** |
| 236 | * Contexts: | 337 | * Contexts: |
| 237 | * ComplexObject returns BooleanObject | 338 | * AssertionOrDefinition returns MetricDefinition |
| 238 | * Object returns BooleanObject | ||
| 239 | * DataObject returns BooleanObject | ||
| 240 | * BooleanObject returns BooleanObject | ||
| 241 | * Literal returns BooleanObject | ||
| 242 | * | 339 | * |
| 243 | * Constraint: | 340 | * Constraint: |
| 244 | * value=BooleanValue | 341 | * (head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) |
| 245 | */ | 342 | */ |
| 246 | protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) { | 343 | protected void sequence_AssertionOrDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
| 247 | if (errorAcceptor != null) { | 344 | if (errorAcceptor != null) { |
| 248 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES) | 345 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) |
| 249 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE)); | 346 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); |
| 347 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | ||
| 348 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | ||
| 250 | } | 349 | } |
| 251 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 350 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 252 | feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue()); | 351 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), semanticObject.getHead()); |
| 352 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody()); | ||
| 253 | feeder.finish(); | 353 | feeder.finish(); |
| 254 | } | 354 | } |
| 255 | 355 | ||
| 256 | 356 | ||
| 257 | /** | 357 | /** |
| 258 | * Contexts: | 358 | * Contexts: |
| 259 | * Symbol returns BooleanSymbol | 359 | * Statement returns MetricDefinition |
| 260 | * DataSymbol returns BooleanSymbol | ||
| 261 | * BooleanSymbol returns BooleanSymbol | ||
| 262 | * | 360 | * |
| 263 | * Constraint: | 361 | * Constraint: |
| 264 | * {BooleanSymbol} | 362 | * ((head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) | (type=MetricType head=Expression body=Expression)) |
| 265 | */ | 363 | */ |
| 266 | protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) { | 364 | protected void sequence_AssertionOrDefinition_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
| 267 | genericSequencer.createSequence(context, semanticObject); | 365 | genericSequencer.createSequence(context, semanticObject); |
| 268 | } | 366 | } |
| 269 | 367 | ||
| 270 | 368 | ||
| 271 | /** | 369 | /** |
| 272 | * Contexts: | 370 | * Contexts: |
| 273 | * BooleanValue returns BooleanFalse | 371 | * AssertionOrDefinition returns PredicateDefinition |
| 274 | * | 372 | * |
| 275 | * Constraint: | 373 | * Constraint: |
| 276 | * {BooleanFalse} | 374 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) |
| 277 | */ | 375 | */ |
| 278 | protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) { | 376 | protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
| 279 | genericSequencer.createSequence(context, semanticObject); | 377 | if (errorAcceptor != null) { |
| 378 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD) == ValueTransient.YES) | ||
| 379 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD)); | ||
| 380 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY) == ValueTransient.YES) | ||
| 381 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY)); | ||
| 382 | } | ||
| 383 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 384 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead()); | ||
| 385 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
| 386 | feeder.finish(); | ||
| 280 | } | 387 | } |
| 281 | 388 | ||
| 282 | 389 | ||
| 283 | /** | 390 | /** |
| 284 | * Contexts: | 391 | * Contexts: |
| 285 | * BooleanValue returns BooleanTrue | 392 | * Statement returns PredicateDefinition |
| 286 | * | 393 | * |
| 287 | * Constraint: | 394 | * Constraint: |
| 288 | * {BooleanTrue} | 395 | * ( |
| 396 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) | | ||
| 397 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) | ||
| 398 | * ) | ||
| 289 | */ | 399 | */ |
| 290 | protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) { | 400 | protected void sequence_AssertionOrDefinition_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
| 291 | genericSequencer.createSequence(context, semanticObject); | 401 | genericSequencer.createSequence(context, semanticObject); |
| 292 | } | 402 | } |
| 293 | 403 | ||
| 294 | 404 | ||
| 295 | /** | 405 | /** |
| 296 | * Contexts: | 406 | * Contexts: |
| 297 | * Statement returns ClassInterpretation | 407 | * Multiplicity returns BoundedMultiplicity |
| 298 | * Interpretation returns ClassInterpretation | 408 | * BoundedMultiplicity returns BoundedMultiplicity |
| 299 | * CDInterpretation returns ClassInterpretation | ||
| 300 | * ClassInterpretation returns ClassInterpretation | ||
| 301 | * | 409 | * |
| 302 | * Constraint: | 410 | * Constraint: |
| 303 | * (abstract?='abstract'? symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*) | 411 | * (lowerBound=INT upperBound=UpperMultiplicty) |
| 304 | */ | 412 | */ |
| 305 | protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) { | 413 | protected void sequence_BoundedMultiplicity(ISerializationContext context, BoundedMultiplicity semanticObject) { |
| 306 | genericSequencer.createSequence(context, semanticObject); | 414 | if (errorAcceptor != null) { |
| 415 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND) == ValueTransient.YES) | ||
| 416 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND)); | ||
| 417 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND) == ValueTransient.YES) | ||
| 418 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND)); | ||
| 419 | } | ||
| 420 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 421 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0(), semanticObject.getLowerBound()); | ||
| 422 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
| 423 | feeder.finish(); | ||
| 307 | } | 424 | } |
| 308 | 425 | ||
| 309 | 426 | ||
| 310 | /** | 427 | /** |
| 311 | * Contexts: | 428 | * Contexts: |
| 312 | * ClosureType returns IrreflexiveClosure | 429 | * Statement returns BoundedScopeDefinition |
| 430 | * ScopeDefinition returns BoundedScopeDefinition | ||
| 431 | * BoundedScopeDefinition returns BoundedScopeDefinition | ||
| 313 | * | 432 | * |
| 314 | * Constraint: | 433 | * Constraint: |
| 315 | * {IrreflexiveClosure} | 434 | * ((lowerBound=INT? type=[NamedElement|QualifiedName] upperBound=INT) | (upperBound=INT type=[NamedElement|QualifiedName] lowerBound=INT?)) |
| 316 | */ | 435 | */ |
| 317 | protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) { | 436 | protected void sequence_BoundedScopeDefinition(ISerializationContext context, BoundedScopeDefinition semanticObject) { |
| 318 | genericSequencer.createSequence(context, semanticObject); | 437 | genericSequencer.createSequence(context, semanticObject); |
| 319 | } | 438 | } |
| 320 | 439 | ||
| 321 | 440 | ||
| 322 | /** | 441 | /** |
| 323 | * Contexts: | 442 | * Contexts: |
| 324 | * ClosureType returns ReflexiveClosure | 443 | * AssertionOrDefinition.Assertion_1_0_0 returns Call |
| 444 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call | ||
| 445 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Call | ||
| 446 | * Expression returns Call | ||
| 447 | * DisjunctiveExpression returns Call | ||
| 448 | * DisjunctiveExpression.Disjunction_1_0_0 returns Call | ||
| 449 | * DisjunctiveExpression.Case_1_1_0 returns Call | ||
| 450 | * ConjunctiveExpression returns Call | ||
| 451 | * ConjunctiveExpression.Conjunction_1_0 returns Call | ||
| 452 | * ComparisonExpression returns Call | ||
| 453 | * ComparisonExpression.Comparison_1_0 returns Call | ||
| 454 | * AdditiveExpression returns Call | ||
| 455 | * AdditiveExpression.BinaryExpression_1_0 returns Call | ||
| 456 | * MultiplicativeExpression returns Call | ||
| 457 | * MultiplicativeExpression.BinaryExpression_1_0 returns Call | ||
| 458 | * ExponentialExpression returns Call | ||
| 459 | * ExponentialExpression.BinaryExpression_1_0 returns Call | ||
| 460 | * UnaryExpression returns Call | ||
| 461 | * AggregationExpression returns Call | ||
| 462 | * AtomicExpression returns Call | ||
| 463 | * Call returns Call | ||
| 325 | * | 464 | * |
| 326 | * Constraint: | 465 | * Constraint: |
| 327 | * {ReflexiveClosure} | 466 | * ( |
| 467 | * functor=Reference | ||
| 468 | * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
| 469 | * argumentList=ArgumentList | ||
| 470 | * ) | ||
| 328 | */ | 471 | */ |
| 329 | protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) { | 472 | protected void sequence_Call(ISerializationContext context, Call semanticObject) { |
| 330 | genericSequencer.createSequence(context, semanticObject); | 473 | genericSequencer.createSequence(context, semanticObject); |
| 331 | } | 474 | } |
| 332 | 475 | ||
| 333 | 476 | ||
| 334 | /** | 477 | /** |
| 335 | * Contexts: | 478 | * Contexts: |
| 336 | * Constraint returns Constraint | 479 | * Case returns Case |
| 480 | * | ||
| 481 | * Constraint: | ||
| 482 | * (condition=ConjunctiveExpression body=ConjunctiveExpression) | ||
| 483 | */ | ||
| 484 | protected void sequence_Case(ISerializationContext context, Case semanticObject) { | ||
| 485 | if (errorAcceptor != null) { | ||
| 486 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) | ||
| 487 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); | ||
| 488 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
| 489 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
| 490 | } | ||
| 491 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 492 | feeder.accept(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0(), semanticObject.getCondition()); | ||
| 493 | feeder.accept(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
| 494 | feeder.finish(); | ||
| 495 | } | ||
| 496 | |||
| 497 | |||
| 498 | /** | ||
| 499 | * Contexts: | ||
| 500 | * Statement returns ClassDefinition | ||
| 501 | * ClassDefinition returns ClassDefinition | ||
| 337 | * | 502 | * |
| 338 | * Constraint: | 503 | * Constraint: |
| 339 | * ((polarity=Polarity? symbol=ModelSymbol params+=Literal? params+=Literal*) | (closureType=ClosureType params+=Literal? params+=Literal*)) | 504 | * ( |
| 505 | * abstract?='abstract'? | ||
| 506 | * name=ID | ||
| 507 | * (superclasses+=[NamedElement|QualifiedName] superclasses+=[NamedElement|QualifiedName]*)? | ||
| 508 | * members+=MemberDefinition* | ||
| 509 | * ) | ||
| 340 | */ | 510 | */ |
| 341 | protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) { | 511 | protected void sequence_ClassDefinition(ISerializationContext context, ClassDefinition semanticObject) { |
| 342 | genericSequencer.createSequence(context, semanticObject); | 512 | genericSequencer.createSequence(context, semanticObject); |
| 343 | } | 513 | } |
| 344 | 514 | ||
| 345 | 515 | ||
| 346 | /** | 516 | /** |
| 347 | * Contexts: | 517 | * Contexts: |
| 348 | * Statement returns DefaultInterpretation | 518 | * AssertionOrDefinition.Assertion_1_0_0 returns Comparison |
| 349 | * Interpretation returns DefaultInterpretation | 519 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Comparison |
| 350 | * DefaultInterpretation returns DefaultInterpretation | 520 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Comparison |
| 521 | * Expression returns Comparison | ||
| 522 | * DisjunctiveExpression returns Comparison | ||
| 523 | * DisjunctiveExpression.Disjunction_1_0_0 returns Comparison | ||
| 524 | * DisjunctiveExpression.Case_1_1_0 returns Comparison | ||
| 525 | * ConjunctiveExpression returns Comparison | ||
| 526 | * ConjunctiveExpression.Conjunction_1_0 returns Comparison | ||
| 527 | * ComparisonExpression returns Comparison | ||
| 528 | * ComparisonExpression.Comparison_1_0 returns Comparison | ||
| 529 | * AdditiveExpression returns Comparison | ||
| 530 | * AdditiveExpression.BinaryExpression_1_0 returns Comparison | ||
| 531 | * MultiplicativeExpression returns Comparison | ||
| 532 | * MultiplicativeExpression.BinaryExpression_1_0 returns Comparison | ||
| 533 | * ExponentialExpression returns Comparison | ||
| 534 | * ExponentialExpression.BinaryExpression_1_0 returns Comparison | ||
| 535 | * UnaryExpression returns Comparison | ||
| 536 | * AggregationExpression returns Comparison | ||
| 537 | * AtomicExpression returns Comparison | ||
| 351 | * | 538 | * |
| 352 | * Constraint: | 539 | * Constraint: |
| 353 | * interpretation=BasicInterpretation | 540 | * (left=ComparisonExpression_Comparison_1_0 op=ComparisonOperator right=AdditiveExpression) |
| 354 | */ | 541 | */ |
| 355 | protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) { | 542 | protected void sequence_ComparisonExpression(ISerializationContext context, Comparison semanticObject) { |
| 356 | if (errorAcceptor != null) { | 543 | if (errorAcceptor != null) { |
| 357 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES) | 544 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT) == ValueTransient.YES) |
| 358 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION)); | 545 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT)); |
| 546 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP) == ValueTransient.YES) | ||
| 547 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP)); | ||
| 548 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT) == ValueTransient.YES) | ||
| 549 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT)); | ||
| 359 | } | 550 | } |
| 360 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 551 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 361 | feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation()); | 552 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), semanticObject.getLeft()); |
| 553 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0(), semanticObject.getOp()); | ||
| 554 | feeder.accept(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0(), semanticObject.getRight()); | ||
| 362 | feeder.finish(); | 555 | feeder.finish(); |
| 363 | } | 556 | } |
| 364 | 557 | ||
| 365 | 558 | ||
| 366 | /** | 559 | /** |
| 367 | * Contexts: | 560 | * Contexts: |
| 368 | * Statement returns EnumInterpretation | 561 | * AssertionOrDefinition.Assertion_1_0_0 returns Conjunction |
| 369 | * Interpretation returns EnumInterpretation | 562 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction |
| 370 | * CDInterpretation returns EnumInterpretation | 563 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Conjunction |
| 371 | * EnumInterpretation returns EnumInterpretation | 564 | * Expression returns Conjunction |
| 565 | * DisjunctiveExpression returns Conjunction | ||
| 566 | * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction | ||
| 567 | * DisjunctiveExpression.Case_1_1_0 returns Conjunction | ||
| 568 | * ConjunctiveExpression returns Conjunction | ||
| 569 | * ConjunctiveExpression.Conjunction_1_0 returns Conjunction | ||
| 570 | * ComparisonExpression returns Conjunction | ||
| 571 | * ComparisonExpression.Comparison_1_0 returns Conjunction | ||
| 572 | * AdditiveExpression returns Conjunction | ||
| 573 | * AdditiveExpression.BinaryExpression_1_0 returns Conjunction | ||
| 574 | * MultiplicativeExpression returns Conjunction | ||
| 575 | * MultiplicativeExpression.BinaryExpression_1_0 returns Conjunction | ||
| 576 | * ExponentialExpression returns Conjunction | ||
| 577 | * ExponentialExpression.BinaryExpression_1_0 returns Conjunction | ||
| 578 | * UnaryExpression returns Conjunction | ||
| 579 | * AggregationExpression returns Conjunction | ||
| 580 | * AtomicExpression returns Conjunction | ||
| 372 | * | 581 | * |
| 373 | * Constraint: | 582 | * Constraint: |
| 374 | * (Symbol=ModelSymbol objects+=NamedObject+) | 583 | * (children+=ConjunctiveExpression_Conjunction_1_0 children+=ComparisonExpression+) |
| 375 | */ | 584 | */ |
| 376 | protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) { | 585 | protected void sequence_ConjunctiveExpression(ISerializationContext context, Conjunction semanticObject) { |
| 377 | genericSequencer.createSequence(context, semanticObject); | 586 | genericSequencer.createSequence(context, semanticObject); |
| 378 | } | 587 | } |
| 379 | 588 | ||
| 380 | 589 | ||
| 381 | /** | 590 | /** |
| 382 | * Contexts: | 591 | * Contexts: |
| 383 | * Symbol returns EqualsSymbol | 592 | * AssertionOrDefinition.Assertion_1_0_0 returns Count |
| 384 | * PartialitySymbol returns EqualsSymbol | 593 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Count |
| 385 | * EqualsSymbol returns EqualsSymbol | 594 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Count |
| 595 | * Expression returns Count | ||
| 596 | * DisjunctiveExpression returns Count | ||
| 597 | * DisjunctiveExpression.Disjunction_1_0_0 returns Count | ||
| 598 | * DisjunctiveExpression.Case_1_1_0 returns Count | ||
| 599 | * ConjunctiveExpression returns Count | ||
| 600 | * ConjunctiveExpression.Conjunction_1_0 returns Count | ||
| 601 | * ComparisonExpression returns Count | ||
| 602 | * ComparisonExpression.Comparison_1_0 returns Count | ||
| 603 | * AdditiveExpression returns Count | ||
| 604 | * AdditiveExpression.BinaryExpression_1_0 returns Count | ||
| 605 | * MultiplicativeExpression returns Count | ||
| 606 | * MultiplicativeExpression.BinaryExpression_1_0 returns Count | ||
| 607 | * ExponentialExpression returns Count | ||
| 608 | * ExponentialExpression.BinaryExpression_1_0 returns Count | ||
| 609 | * UnaryExpression returns Count | ||
| 610 | * AggregationExpression returns Count | ||
| 611 | * Count returns Count | ||
| 612 | * AtomicExpression returns Count | ||
| 386 | * | 613 | * |
| 387 | * Constraint: | 614 | * Constraint: |
| 388 | * {EqualsSymbol} | 615 | * body=Expression |
| 389 | */ | 616 | */ |
| 390 | protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) { | 617 | protected void sequence_Count(ISerializationContext context, Count semanticObject) { |
| 391 | genericSequencer.createSequence(context, semanticObject); | 618 | if (errorAcceptor != null) { |
| 619 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY) == ValueTransient.YES) | ||
| 620 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY)); | ||
| 621 | } | ||
| 622 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 623 | feeder.accept(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
| 624 | feeder.finish(); | ||
| 392 | } | 625 | } |
| 393 | 626 | ||
| 394 | 627 | ||
| 395 | /** | 628 | /** |
| 396 | * Contexts: | 629 | * Contexts: |
| 397 | * Symbol returns ExistSymbol | 630 | * Statement returns DefaultDefinition |
| 398 | * PartialitySymbol returns ExistSymbol | 631 | * DefaultDefinition returns DefaultDefinition |
| 399 | * ExistSymbol returns ExistSymbol | ||
| 400 | * | 632 | * |
| 401 | * Constraint: | 633 | * Constraint: |
| 402 | * {ExistSymbol} | 634 | * (head=Call range=Expression) |
| 403 | */ | 635 | */ |
| 404 | protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) { | 636 | protected void sequence_DefaultDefinition(ISerializationContext context, DefaultDefinition semanticObject) { |
| 405 | genericSequencer.createSequence(context, semanticObject); | 637 | if (errorAcceptor != null) { |
| 638 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD) == ValueTransient.YES) | ||
| 639 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD)); | ||
| 640 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE) == ValueTransient.YES) | ||
| 641 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE)); | ||
| 642 | } | ||
| 643 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 644 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | ||
| 645 | feeder.accept(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0(), semanticObject.getRange()); | ||
| 646 | feeder.finish(); | ||
| 406 | } | 647 | } |
| 407 | 648 | ||
| 408 | 649 | ||
| 409 | /** | 650 | /** |
| 410 | * Contexts: | 651 | * Contexts: |
| 411 | * FieldRelationInterpretation returns FieldRelationInterpretation | 652 | * AssertionOrDefinition.Assertion_1_0_0 returns Disjunction |
| 653 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction | ||
| 654 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Disjunction | ||
| 655 | * Expression returns Disjunction | ||
| 656 | * DisjunctiveExpression returns Disjunction | ||
| 657 | * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction | ||
| 658 | * DisjunctiveExpression.Case_1_1_0 returns Disjunction | ||
| 659 | * ConjunctiveExpression returns Disjunction | ||
| 660 | * ConjunctiveExpression.Conjunction_1_0 returns Disjunction | ||
| 661 | * ComparisonExpression returns Disjunction | ||
| 662 | * ComparisonExpression.Comparison_1_0 returns Disjunction | ||
| 663 | * AdditiveExpression returns Disjunction | ||
| 664 | * AdditiveExpression.BinaryExpression_1_0 returns Disjunction | ||
| 665 | * MultiplicativeExpression returns Disjunction | ||
| 666 | * MultiplicativeExpression.BinaryExpression_1_0 returns Disjunction | ||
| 667 | * ExponentialExpression returns Disjunction | ||
| 668 | * ExponentialExpression.BinaryExpression_1_0 returns Disjunction | ||
| 669 | * UnaryExpression returns Disjunction | ||
| 670 | * AggregationExpression returns Disjunction | ||
| 671 | * AtomicExpression returns Disjunction | ||
| 412 | * | 672 | * |
| 413 | * Constraint: | 673 | * Constraint: |
| 414 | * (containment?='containment'? symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol) | 674 | * (children+=DisjunctiveExpression_Disjunction_1_0_0 children+=ConjunctiveExpression+) |
| 415 | */ | 675 | */ |
| 416 | protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) { | 676 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Disjunction semanticObject) { |
| 417 | genericSequencer.createSequence(context, semanticObject); | 677 | genericSequencer.createSequence(context, semanticObject); |
| 418 | } | 678 | } |
| 419 | 679 | ||
| 420 | 680 | ||
| 421 | /** | 681 | /** |
| 422 | * Contexts: | 682 | * Contexts: |
| 423 | * Statement returns GlobalRelationInterpretation | 683 | * AssertionOrDefinition.Assertion_1_0_0 returns Switch |
| 424 | * Interpretation returns GlobalRelationInterpretation | 684 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch |
| 425 | * CDInterpretation returns GlobalRelationInterpretation | 685 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Switch |
| 426 | * GlobalRelationInterpretation returns GlobalRelationInterpretation | 686 | * Expression returns Switch |
| 687 | * DisjunctiveExpression returns Switch | ||
| 688 | * DisjunctiveExpression.Disjunction_1_0_0 returns Switch | ||
| 689 | * DisjunctiveExpression.Case_1_1_0 returns Switch | ||
| 690 | * ConjunctiveExpression returns Switch | ||
| 691 | * ConjunctiveExpression.Conjunction_1_0 returns Switch | ||
| 692 | * ComparisonExpression returns Switch | ||
| 693 | * ComparisonExpression.Comparison_1_0 returns Switch | ||
| 694 | * AdditiveExpression returns Switch | ||
| 695 | * AdditiveExpression.BinaryExpression_1_0 returns Switch | ||
| 696 | * MultiplicativeExpression returns Switch | ||
| 697 | * MultiplicativeExpression.BinaryExpression_1_0 returns Switch | ||
| 698 | * ExponentialExpression returns Switch | ||
| 699 | * ExponentialExpression.BinaryExpression_1_0 returns Switch | ||
| 700 | * UnaryExpression returns Switch | ||
| 701 | * AggregationExpression returns Switch | ||
| 702 | * AtomicExpression returns Switch | ||
| 427 | * | 703 | * |
| 428 | * Constraint: | 704 | * Constraint: |
| 429 | * ( | 705 | * (cases+=DisjunctiveExpression_Switch_1_1_3 cases+=Case*) |
| 430 | * containment?='containment'? | ||
| 431 | * symbol=ModelSymbol | ||
| 432 | * sourceMultiplicity=MultiplicityDefinition? | ||
| 433 | * source=Symbol | ||
| 434 | * targetMultiplicity=MultiplicityDefinition? | ||
| 435 | * target=Symbol | ||
| 436 | * ) | ||
| 437 | */ | 706 | */ |
| 438 | protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) { | 707 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Switch semanticObject) { |
| 439 | genericSequencer.createSequence(context, semanticObject); | 708 | genericSequencer.createSequence(context, semanticObject); |
| 440 | } | 709 | } |
| 441 | 710 | ||
| 442 | 711 | ||
| 443 | /** | 712 | /** |
| 444 | * Contexts: | 713 | * Contexts: |
| 445 | * ComplexObject returns IntObject | 714 | * DisjunctiveExpression.Switch_1_1_3 returns Case |
| 446 | * Object returns IntObject | ||
| 447 | * DataObject returns IntObject | ||
| 448 | * IntObject returns IntObject | ||
| 449 | * Literal returns IntObject | ||
| 450 | * | 715 | * |
| 451 | * Constraint: | 716 | * Constraint: |
| 452 | * value=INTLiteral | 717 | * (condition=DisjunctiveExpression_Case_1_1_0 body=ConjunctiveExpression) |
| 453 | */ | 718 | */ |
| 454 | protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) { | 719 | protected void sequence_DisjunctiveExpression_Switch_1_1_3(ISerializationContext context, Case semanticObject) { |
| 455 | if (errorAcceptor != null) { | 720 | if (errorAcceptor != null) { |
| 456 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES) | 721 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) |
| 457 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE)); | 722 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); |
| 723 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
| 724 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
| 458 | } | 725 | } |
| 459 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 726 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 460 | feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue()); | 727 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), semanticObject.getCondition()); |
| 728 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
| 461 | feeder.finish(); | 729 | feeder.finish(); |
| 462 | } | 730 | } |
| 463 | 731 | ||
| 464 | 732 | ||
| 465 | /** | 733 | /** |
| 466 | * Contexts: | 734 | * Contexts: |
| 467 | * Symbol returns IntegerSymbol | 735 | * AssertionOrDefinition.Assertion_1_0_0 returns EmptyIntervalLiteral |
| 468 | * DataSymbol returns IntegerSymbol | 736 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyIntervalLiteral |
| 469 | * IntegerSymbol returns IntegerSymbol | 737 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns EmptyIntervalLiteral |
| 738 | * Expression returns EmptyIntervalLiteral | ||
| 739 | * DisjunctiveExpression returns EmptyIntervalLiteral | ||
| 740 | * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyIntervalLiteral | ||
| 741 | * DisjunctiveExpression.Case_1_1_0 returns EmptyIntervalLiteral | ||
| 742 | * ConjunctiveExpression returns EmptyIntervalLiteral | ||
| 743 | * ConjunctiveExpression.Conjunction_1_0 returns EmptyIntervalLiteral | ||
| 744 | * ComparisonExpression returns EmptyIntervalLiteral | ||
| 745 | * ComparisonExpression.Comparison_1_0 returns EmptyIntervalLiteral | ||
| 746 | * AdditiveExpression returns EmptyIntervalLiteral | ||
| 747 | * AdditiveExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
| 748 | * MultiplicativeExpression returns EmptyIntervalLiteral | ||
| 749 | * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
| 750 | * ExponentialExpression returns EmptyIntervalLiteral | ||
| 751 | * ExponentialExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral | ||
| 752 | * UnaryExpression returns EmptyIntervalLiteral | ||
| 753 | * AggregationExpression returns EmptyIntervalLiteral | ||
| 754 | * AtomicExpression returns EmptyIntervalLiteral | ||
| 755 | * Literal returns EmptyIntervalLiteral | ||
| 756 | * EmptyIntervalLiteral returns EmptyIntervalLiteral | ||
| 470 | * | 757 | * |
| 471 | * Constraint: | 758 | * Constraint: |
| 472 | * {IntegerSymbol} | 759 | * {EmptyIntervalLiteral} |
| 473 | */ | 760 | */ |
| 474 | protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) { | 761 | protected void sequence_EmptyIntervalLiteral(ISerializationContext context, EmptyIntervalLiteral semanticObject) { |
| 475 | genericSequencer.createSequence(context, semanticObject); | 762 | genericSequencer.createSequence(context, semanticObject); |
| 476 | } | 763 | } |
| 477 | 764 | ||
| 478 | 765 | ||
| 479 | /** | 766 | /** |
| 480 | * Contexts: | 767 | * Contexts: |
| 481 | * Symbol returns ModelSymbol | 768 | * Multiplicity returns ExactMultiplicity |
| 482 | * ModelSymbol returns ModelSymbol | 769 | * ExactMultiplicity returns ExactMultiplicity |
| 483 | * | 770 | * |
| 484 | * Constraint: | 771 | * Constraint: |
| 485 | * name=ID | 772 | * multiplicity=UpperMultiplicty |
| 486 | */ | 773 | */ |
| 487 | protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) { | 774 | protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { |
| 488 | if (errorAcceptor != null) { | 775 | if (errorAcceptor != null) { |
| 489 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES) | 776 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY) == ValueTransient.YES) |
| 490 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME)); | 777 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY)); |
| 491 | } | 778 | } |
| 492 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 779 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 493 | feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 780 | feeder.accept(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0(), semanticObject.getMultiplicity()); |
| 494 | feeder.finish(); | 781 | feeder.finish(); |
| 495 | } | 782 | } |
| 496 | 783 | ||
| 497 | 784 | ||
| 498 | /** | 785 | /** |
| 499 | * Contexts: | 786 | * Contexts: |
| 500 | * MultiplicityDefinition returns MultiplicityDefinition | 787 | * Statement returns ExactScopeDefinition |
| 788 | * ScopeDefinition returns ExactScopeDefinition | ||
| 789 | * ExactScopeDefinition returns ExactScopeDefinition | ||
| 501 | * | 790 | * |
| 502 | * Constraint: | 791 | * Constraint: |
| 503 | * (lower=INT (upper=INT | unlimitedUpper?='*')) | 792 | * (type=[NamedElement|QualifiedName] exactScope=INT) |
| 504 | */ | 793 | */ |
| 505 | protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) { | 794 | protected void sequence_ExactScopeDefinition(ISerializationContext context, ExactScopeDefinition semanticObject) { |
| 506 | genericSequencer.createSequence(context, semanticObject); | 795 | if (errorAcceptor != null) { |
| 796 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE) == ValueTransient.YES) | ||
| 797 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE)); | ||
| 798 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE) == ValueTransient.YES) | ||
| 799 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE)); | ||
| 800 | } | ||
| 801 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 802 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE, false)); | ||
| 803 | feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0(), semanticObject.getExactScope()); | ||
| 804 | feeder.finish(); | ||
| 507 | } | 805 | } |
| 508 | 806 | ||
| 509 | 807 | ||
| 510 | /** | 808 | /** |
| 511 | * Contexts: | 809 | * Contexts: |
| 512 | * ComplexObject returns NamedObject | 810 | * Argument returns ExpressionArgument |
| 513 | * Object returns NamedObject | 811 | * ExpressionArgument returns ExpressionArgument |
| 514 | * NamedObject returns NamedObject | ||
| 515 | * Literal returns NamedObject | ||
| 516 | * | 812 | * |
| 517 | * Constraint: | 813 | * Constraint: |
| 518 | * name=ID | 814 | * body=ComparisonExpression |
| 519 | */ | 815 | */ |
| 520 | protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) { | 816 | protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) { |
| 521 | if (errorAcceptor != null) { | 817 | if (errorAcceptor != null) { |
| 522 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES) | 818 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY) == ValueTransient.YES) |
| 523 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME)); | 819 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY)); |
| 524 | } | 820 | } |
| 525 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 821 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 526 | feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); | 822 | feeder.accept(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0(), semanticObject.getBody()); |
| 527 | feeder.finish(); | 823 | feeder.finish(); |
| 528 | } | 824 | } |
| 529 | 825 | ||
| 530 | 826 | ||
| 531 | /** | 827 | /** |
| 532 | * Contexts: | 828 | * Contexts: |
| 533 | * Parameter returns Parameter | 829 | * Statement returns ExternMetricDefinition |
| 830 | * ExternMetricDefinition returns ExternMetricDefinition | ||
| 534 | * | 831 | * |
| 535 | * Constraint: | 832 | * Constraint: |
| 536 | * (variable=Variable type=Symbol?) | 833 | * (type=MetricType head=Call) |
| 537 | */ | 834 | */ |
| 538 | protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) { | 835 | protected void sequence_ExternMetricDefinition(ISerializationContext context, ExternMetricDefinition semanticObject) { |
| 539 | genericSequencer.createSequence(context, semanticObject); | 836 | if (errorAcceptor != null) { |
| 837 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE) == ValueTransient.YES) | ||
| 838 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE)); | ||
| 839 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD) == ValueTransient.YES) | ||
| 840 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD)); | ||
| 841 | } | ||
| 842 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 843 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0(), semanticObject.getType()); | ||
| 844 | feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0(), semanticObject.getHead()); | ||
| 845 | feeder.finish(); | ||
| 540 | } | 846 | } |
| 541 | 847 | ||
| 542 | 848 | ||
| 543 | /** | 849 | /** |
| 544 | * Contexts: | 850 | * Contexts: |
| 545 | * PatternBody returns PatternBody | 851 | * Statement returns ExternPredicateDefinition |
| 852 | * ExternPredicateDefinition returns ExternPredicateDefinition | ||
| 546 | * | 853 | * |
| 547 | * Constraint: | 854 | * Constraint: |
| 548 | * constraints+=Constraint* | 855 | * head=Call |
| 549 | */ | 856 | */ |
| 550 | protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) { | 857 | protected void sequence_ExternPredicateDefinition(ISerializationContext context, ExternPredicateDefinition semanticObject) { |
| 551 | genericSequencer.createSequence(context, semanticObject); | 858 | if (errorAcceptor != null) { |
| 859 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD) == ValueTransient.YES) | ||
| 860 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD)); | ||
| 861 | } | ||
| 862 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 863 | feeder.accept(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | ||
| 864 | feeder.finish(); | ||
| 865 | } | ||
| 866 | |||
| 867 | |||
| 868 | /** | ||
| 869 | * Contexts: | ||
| 870 | * AssertionOrDefinition.Assertion_1_0_0 returns IfElse | ||
| 871 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IfElse | ||
| 872 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns IfElse | ||
| 873 | * Expression returns IfElse | ||
| 874 | * IfElse returns IfElse | ||
| 875 | * DisjunctiveExpression returns IfElse | ||
| 876 | * DisjunctiveExpression.Disjunction_1_0_0 returns IfElse | ||
| 877 | * DisjunctiveExpression.Case_1_1_0 returns IfElse | ||
| 878 | * ConjunctiveExpression returns IfElse | ||
| 879 | * ConjunctiveExpression.Conjunction_1_0 returns IfElse | ||
| 880 | * ComparisonExpression returns IfElse | ||
| 881 | * ComparisonExpression.Comparison_1_0 returns IfElse | ||
| 882 | * AdditiveExpression returns IfElse | ||
| 883 | * AdditiveExpression.BinaryExpression_1_0 returns IfElse | ||
| 884 | * MultiplicativeExpression returns IfElse | ||
| 885 | * MultiplicativeExpression.BinaryExpression_1_0 returns IfElse | ||
| 886 | * ExponentialExpression returns IfElse | ||
| 887 | * ExponentialExpression.BinaryExpression_1_0 returns IfElse | ||
| 888 | * UnaryExpression returns IfElse | ||
| 889 | * AggregationExpression returns IfElse | ||
| 890 | * AtomicExpression returns IfElse | ||
| 891 | * | ||
| 892 | * Constraint: | ||
| 893 | * (condition=Expression then=Expression else=Expression) | ||
| 894 | */ | ||
| 895 | protected void sequence_IfElse(ISerializationContext context, IfElse semanticObject) { | ||
| 896 | if (errorAcceptor != null) { | ||
| 897 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION) == ValueTransient.YES) | ||
| 898 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION)); | ||
| 899 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN) == ValueTransient.YES) | ||
| 900 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN)); | ||
| 901 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE) == ValueTransient.YES) | ||
| 902 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE)); | ||
| 903 | } | ||
| 904 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 905 | feeder.accept(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition()); | ||
| 906 | feeder.accept(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen()); | ||
| 907 | feeder.accept(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse()); | ||
| 908 | feeder.finish(); | ||
| 552 | } | 909 | } |
| 553 | 910 | ||
| 554 | 911 | ||
| 555 | /** | 912 | /** |
| 556 | * Contexts: | 913 | * Contexts: |
| 557 | * Polarity returns Negative | 914 | * AssertionOrDefinition.Assertion_1_0_0 returns InfinityLiteral |
| 915 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral | ||
| 916 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns InfinityLiteral | ||
| 917 | * Expression returns InfinityLiteral | ||
| 918 | * DisjunctiveExpression returns InfinityLiteral | ||
| 919 | * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral | ||
| 920 | * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral | ||
| 921 | * ConjunctiveExpression returns InfinityLiteral | ||
| 922 | * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral | ||
| 923 | * ComparisonExpression returns InfinityLiteral | ||
| 924 | * ComparisonExpression.Comparison_1_0 returns InfinityLiteral | ||
| 925 | * AdditiveExpression returns InfinityLiteral | ||
| 926 | * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
| 927 | * MultiplicativeExpression returns InfinityLiteral | ||
| 928 | * MultiplicativeExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
| 929 | * ExponentialExpression returns InfinityLiteral | ||
| 930 | * ExponentialExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
| 931 | * UnaryExpression returns InfinityLiteral | ||
| 932 | * AggregationExpression returns InfinityLiteral | ||
| 933 | * AtomicExpression returns InfinityLiteral | ||
| 934 | * Literal returns InfinityLiteral | ||
| 935 | * InfinityLiteral returns InfinityLiteral | ||
| 558 | * | 936 | * |
| 559 | * Constraint: | 937 | * Constraint: |
| 560 | * {Negative} | 938 | * {InfinityLiteral} |
| 561 | */ | 939 | */ |
| 562 | protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) { | 940 | protected void sequence_InfinityLiteral(ISerializationContext context, InfinityLiteral semanticObject) { |
| 563 | genericSequencer.createSequence(context, semanticObject); | 941 | genericSequencer.createSequence(context, semanticObject); |
| 564 | } | 942 | } |
| 565 | 943 | ||
| 566 | 944 | ||
| 567 | /** | 945 | /** |
| 568 | * Contexts: | 946 | * Contexts: |
| 569 | * Polarity returns Positive | 947 | * AssertionOrDefinition.Assertion_1_0_0 returns Interval |
| 948 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval | ||
| 949 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Interval | ||
| 950 | * Expression returns Interval | ||
| 951 | * DisjunctiveExpression returns Interval | ||
| 952 | * DisjunctiveExpression.Disjunction_1_0_0 returns Interval | ||
| 953 | * DisjunctiveExpression.Case_1_1_0 returns Interval | ||
| 954 | * ConjunctiveExpression returns Interval | ||
| 955 | * ConjunctiveExpression.Conjunction_1_0 returns Interval | ||
| 956 | * ComparisonExpression returns Interval | ||
| 957 | * ComparisonExpression.Comparison_1_0 returns Interval | ||
| 958 | * AdditiveExpression returns Interval | ||
| 959 | * AdditiveExpression.BinaryExpression_1_0 returns Interval | ||
| 960 | * MultiplicativeExpression returns Interval | ||
| 961 | * MultiplicativeExpression.BinaryExpression_1_0 returns Interval | ||
| 962 | * ExponentialExpression returns Interval | ||
| 963 | * ExponentialExpression.BinaryExpression_1_0 returns Interval | ||
| 964 | * UnaryExpression returns Interval | ||
| 965 | * AggregationExpression returns Interval | ||
| 966 | * AtomicExpression returns Interval | ||
| 967 | * Interval returns Interval | ||
| 570 | * | 968 | * |
| 571 | * Constraint: | 969 | * Constraint: |
| 572 | * {Positive} | 970 | * (lowerBound=Expression upperBound=Expression) |
| 573 | */ | 971 | */ |
| 574 | protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) { | 972 | protected void sequence_Interval(ISerializationContext context, Interval semanticObject) { |
| 973 | if (errorAcceptor != null) { | ||
| 974 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND) == ValueTransient.YES) | ||
| 975 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND)); | ||
| 976 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND) == ValueTransient.YES) | ||
| 977 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND)); | ||
| 978 | } | ||
| 979 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 980 | feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0(), semanticObject.getLowerBound()); | ||
| 981 | feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
| 982 | feeder.finish(); | ||
| 983 | } | ||
| 984 | |||
| 985 | |||
| 986 | /** | ||
| 987 | * Contexts: | ||
| 988 | * AssertionOrDefinition.Assertion_1_0_0 returns LogicLiteral | ||
| 989 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral | ||
| 990 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns LogicLiteral | ||
| 991 | * Expression returns LogicLiteral | ||
| 992 | * DisjunctiveExpression returns LogicLiteral | ||
| 993 | * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral | ||
| 994 | * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral | ||
| 995 | * ConjunctiveExpression returns LogicLiteral | ||
| 996 | * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral | ||
| 997 | * ComparisonExpression returns LogicLiteral | ||
| 998 | * ComparisonExpression.Comparison_1_0 returns LogicLiteral | ||
| 999 | * AdditiveExpression returns LogicLiteral | ||
| 1000 | * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral | ||
| 1001 | * MultiplicativeExpression returns LogicLiteral | ||
| 1002 | * MultiplicativeExpression.BinaryExpression_1_0 returns LogicLiteral | ||
| 1003 | * ExponentialExpression returns LogicLiteral | ||
| 1004 | * ExponentialExpression.BinaryExpression_1_0 returns LogicLiteral | ||
| 1005 | * UnaryExpression returns LogicLiteral | ||
| 1006 | * AggregationExpression returns LogicLiteral | ||
| 1007 | * AtomicExpression returns LogicLiteral | ||
| 1008 | * Literal returns LogicLiteral | ||
| 1009 | * LogicLiteral returns LogicLiteral | ||
| 1010 | * | ||
| 1011 | * Constraint: | ||
| 1012 | * value=LogicValue | ||
| 1013 | */ | ||
| 1014 | protected void sequence_LogicLiteral(ISerializationContext context, LogicLiteral semanticObject) { | ||
| 1015 | if (errorAcceptor != null) { | ||
| 1016 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE) == ValueTransient.YES) | ||
| 1017 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE)); | ||
| 1018 | } | ||
| 1019 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1020 | feeder.accept(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0(), semanticObject.getValue()); | ||
| 1021 | feeder.finish(); | ||
| 1022 | } | ||
| 1023 | |||
| 1024 | |||
| 1025 | /** | ||
| 1026 | * Contexts: | ||
| 1027 | * Statement returns LowerBoundedScopeDefinition | ||
| 1028 | * ScopeDefinition returns LowerBoundedScopeDefinition | ||
| 1029 | * LowerBoundedScopeDefinition returns LowerBoundedScopeDefinition | ||
| 1030 | * | ||
| 1031 | * Constraint: | ||
| 1032 | * ((lowerBound=INT type=[NamedElement|QualifiedName]) | (type=[NamedElement|QualifiedName] lowerBound=INT)) | ||
| 1033 | */ | ||
| 1034 | protected void sequence_LowerBoundedScopeDefinition(ISerializationContext context, LowerBoundedScopeDefinition semanticObject) { | ||
| 575 | genericSequencer.createSequence(context, semanticObject); | 1035 | genericSequencer.createSequence(context, semanticObject); |
| 576 | } | 1036 | } |
| 577 | 1037 | ||
| 578 | 1038 | ||
| 579 | /** | 1039 | /** |
| 580 | * Contexts: | 1040 | * Contexts: |
| 581 | * Statement returns Predicate | 1041 | * Multiplicity returns ManyMultiplicity |
| 582 | * Predicate returns Predicate | 1042 | * ManyMultiplicity returns ManyMultiplicity |
| 583 | * | 1043 | * |
| 584 | * Constraint: | 1044 | * Constraint: |
| 585 | * (isError?='error'? symbol=ModelSymbol (parameters+=Parameter parameters+=Parameter*)? (bodies+=PatternBody bodies+=PatternBody*)?) | 1045 | * {ManyMultiplicity} |
| 586 | */ | 1046 | */ |
| 587 | protected void sequence_Predicate(ISerializationContext context, Predicate semanticObject) { | 1047 | protected void sequence_ManyMultiplicity(ISerializationContext context, ManyMultiplicity semanticObject) { |
| 588 | genericSequencer.createSequence(context, semanticObject); | 1048 | genericSequencer.createSequence(context, semanticObject); |
| 589 | } | 1049 | } |
| 590 | 1050 | ||
| 591 | 1051 | ||
| 592 | /** | 1052 | /** |
| 593 | * Contexts: | 1053 | * Contexts: |
| 594 | * Problem returns Problem | 1054 | * MemberDefinition returns MemberDefinition |
| 595 | * | 1055 | * |
| 596 | * Constraint: | 1056 | * Constraint: |
| 597 | * statements+=Statement+ | 1057 | * (containment?='contains'? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID opposite=[NamedElement|QualifiedName]?) |
| 598 | */ | 1058 | */ |
| 599 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { | 1059 | protected void sequence_MemberDefinition(ISerializationContext context, MemberDefinition semanticObject) { |
| 600 | genericSequencer.createSequence(context, semanticObject); | 1060 | genericSequencer.createSequence(context, semanticObject); |
| 601 | } | 1061 | } |
| 602 | 1062 | ||
| 603 | 1063 | ||
| 604 | /** | 1064 | /** |
| 605 | * Contexts: | 1065 | * Contexts: |
| 606 | * ComplexObject returns RealObject | 1066 | * MetricDefinition returns MetricDefinition |
| 607 | * Object returns RealObject | ||
| 608 | * DataObject returns RealObject | ||
| 609 | * RealObject returns RealObject | ||
| 610 | * Literal returns RealObject | ||
| 611 | * | 1067 | * |
| 612 | * Constraint: | 1068 | * Constraint: |
| 613 | * value=REALLiteral | 1069 | * (type=MetricType head=Expression body=Expression) |
| 614 | */ | 1070 | */ |
| 615 | protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) { | 1071 | protected void sequence_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) { |
| 616 | if (errorAcceptor != null) { | 1072 | if (errorAcceptor != null) { |
| 617 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES) | 1073 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE) == ValueTransient.YES) |
| 618 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE)); | 1074 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE)); |
| 1075 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES) | ||
| 1076 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD)); | ||
| 1077 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES) | ||
| 1078 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY)); | ||
| 619 | } | 1079 | } |
| 620 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1080 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 621 | feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue()); | 1081 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0(), semanticObject.getType()); |
| 1082 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0(), semanticObject.getHead()); | ||
| 1083 | feeder.accept(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
| 622 | feeder.finish(); | 1084 | feeder.finish(); |
| 623 | } | 1085 | } |
| 624 | 1086 | ||
| 625 | 1087 | ||
| 626 | /** | 1088 | /** |
| 627 | * Contexts: | 1089 | * Contexts: |
| 628 | * Symbol returns RealSymbol | 1090 | * NamedElement returns NamedElement |
| 629 | * DataSymbol returns RealSymbol | ||
| 630 | * RealSymbol returns RealSymbol | ||
| 631 | * | 1091 | * |
| 632 | * Constraint: | 1092 | * Constraint: |
| 633 | * {RealSymbol} | 1093 | * name=QualifiedName |
| 634 | */ | 1094 | */ |
| 635 | protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) { | 1095 | protected void sequence_NamedElement(ISerializationContext context, NamedElement semanticObject) { |
| 636 | genericSequencer.createSequence(context, semanticObject); | 1096 | if (errorAcceptor != null) { |
| 1097 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME) == ValueTransient.YES) | ||
| 1098 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME)); | ||
| 1099 | } | ||
| 1100 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1101 | feeder.accept(grammarAccess.getNamedElementAccess().getNameQualifiedNameParserRuleCall_0(), semanticObject.getName()); | ||
| 1102 | feeder.finish(); | ||
| 637 | } | 1103 | } |
| 638 | 1104 | ||
| 639 | 1105 | ||
| 640 | /** | 1106 | /** |
| 641 | * Contexts: | 1107 | * Contexts: |
| 642 | * ComplexObject returns StringObject | 1108 | * AssertionOrDefinition.Assertion_1_0_0 returns NumericLiteral |
| 643 | * Object returns StringObject | 1109 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns NumericLiteral |
| 644 | * DataObject returns StringObject | 1110 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns NumericLiteral |
| 645 | * StringObject returns StringObject | 1111 | * Expression returns NumericLiteral |
| 646 | * Literal returns StringObject | 1112 | * DisjunctiveExpression returns NumericLiteral |
| 1113 | * DisjunctiveExpression.Disjunction_1_0_0 returns NumericLiteral | ||
| 1114 | * DisjunctiveExpression.Case_1_1_0 returns NumericLiteral | ||
| 1115 | * ConjunctiveExpression returns NumericLiteral | ||
| 1116 | * ConjunctiveExpression.Conjunction_1_0 returns NumericLiteral | ||
| 1117 | * ComparisonExpression returns NumericLiteral | ||
| 1118 | * ComparisonExpression.Comparison_1_0 returns NumericLiteral | ||
| 1119 | * AdditiveExpression returns NumericLiteral | ||
| 1120 | * AdditiveExpression.BinaryExpression_1_0 returns NumericLiteral | ||
| 1121 | * MultiplicativeExpression returns NumericLiteral | ||
| 1122 | * MultiplicativeExpression.BinaryExpression_1_0 returns NumericLiteral | ||
| 1123 | * ExponentialExpression returns NumericLiteral | ||
| 1124 | * ExponentialExpression.BinaryExpression_1_0 returns NumericLiteral | ||
| 1125 | * UnaryExpression returns NumericLiteral | ||
| 1126 | * AggregationExpression returns NumericLiteral | ||
| 1127 | * AtomicExpression returns NumericLiteral | ||
| 1128 | * Literal returns NumericLiteral | ||
| 1129 | * NumericLiteral returns NumericLiteral | ||
| 647 | * | 1130 | * |
| 648 | * Constraint: | 1131 | * Constraint: |
| 649 | * value=STRING | 1132 | * value=Real |
| 650 | */ | 1133 | */ |
| 651 | protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) { | 1134 | protected void sequence_NumericLiteral(ISerializationContext context, NumericLiteral semanticObject) { |
| 652 | if (errorAcceptor != null) { | 1135 | if (errorAcceptor != null) { |
| 653 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES) | 1136 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE) == ValueTransient.YES) |
| 654 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE)); | 1137 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE)); |
| 655 | } | 1138 | } |
| 656 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1139 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 657 | feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); | 1140 | feeder.accept(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue()); |
| 658 | feeder.finish(); | 1141 | feeder.finish(); |
| 659 | } | 1142 | } |
| 660 | 1143 | ||
| 661 | 1144 | ||
| 662 | /** | 1145 | /** |
| 663 | * Contexts: | 1146 | * Contexts: |
| 664 | * Symbol returns StringSymbol | 1147 | * Statement returns ObjectiveDefinition |
| 665 | * DataSymbol returns StringSymbol | 1148 | * ObjectiveDefinition returns ObjectiveDefinition |
| 666 | * StringSymbol returns StringSymbol | ||
| 667 | * | 1149 | * |
| 668 | * Constraint: | 1150 | * Constraint: |
| 669 | * {StringSymbol} | 1151 | * (kind=ObjectiveKind objective=Expression) |
| 670 | */ | 1152 | */ |
| 671 | protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) { | 1153 | protected void sequence_ObjectiveDefinition(ISerializationContext context, ObjectiveDefinition semanticObject) { |
| 672 | genericSequencer.createSequence(context, semanticObject); | 1154 | if (errorAcceptor != null) { |
| 1155 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND) == ValueTransient.YES) | ||
| 1156 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND)); | ||
| 1157 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE) == ValueTransient.YES) | ||
| 1158 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE)); | ||
| 1159 | } | ||
| 1160 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1161 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
| 1162 | feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective()); | ||
| 1163 | feeder.finish(); | ||
| 673 | } | 1164 | } |
| 674 | 1165 | ||
| 675 | 1166 | ||
| 676 | /** | 1167 | /** |
| 677 | * Contexts: | 1168 | * Contexts: |
| 678 | * TruthValue returns Error | 1169 | * PredicateDefinition returns PredicateDefinition |
| 679 | * | 1170 | * |
| 680 | * Constraint: | 1171 | * Constraint: |
| 681 | * {Error} | 1172 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) |
| 682 | */ | 1173 | */ |
| 683 | protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) { | 1174 | protected void sequence_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { |
| 684 | genericSequencer.createSequence(context, semanticObject); | 1175 | genericSequencer.createSequence(context, semanticObject); |
| 685 | } | 1176 | } |
| 686 | 1177 | ||
| 687 | 1178 | ||
| 688 | /** | 1179 | /** |
| 689 | * Contexts: | 1180 | * Contexts: |
| 690 | * TruthValue returns False | 1181 | * Problem returns Problem |
| 691 | * | 1182 | * |
| 692 | * Constraint: | 1183 | * Constraint: |
| 693 | * {False} | 1184 | * statements+=Statement+ |
| 694 | */ | 1185 | */ |
| 695 | protected void sequence_TruthValue(ISerializationContext context, False semanticObject) { | 1186 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { |
| 696 | genericSequencer.createSequence(context, semanticObject); | 1187 | genericSequencer.createSequence(context, semanticObject); |
| 697 | } | 1188 | } |
| 698 | 1189 | ||
| 699 | 1190 | ||
| 700 | /** | 1191 | /** |
| 701 | * Contexts: | 1192 | * Contexts: |
| 702 | * TruthValue returns True | 1193 | * AssertionOrDefinition.Assertion_1_0_0 returns Reference |
| 1194 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference | ||
| 1195 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns Reference | ||
| 1196 | * Expression returns Reference | ||
| 1197 | * DisjunctiveExpression returns Reference | ||
| 1198 | * DisjunctiveExpression.Disjunction_1_0_0 returns Reference | ||
| 1199 | * DisjunctiveExpression.Case_1_1_0 returns Reference | ||
| 1200 | * ConjunctiveExpression returns Reference | ||
| 1201 | * ConjunctiveExpression.Conjunction_1_0 returns Reference | ||
| 1202 | * ComparisonExpression returns Reference | ||
| 1203 | * ComparisonExpression.Comparison_1_0 returns Reference | ||
| 1204 | * AdditiveExpression returns Reference | ||
| 1205 | * AdditiveExpression.BinaryExpression_1_0 returns Reference | ||
| 1206 | * MultiplicativeExpression returns Reference | ||
| 1207 | * MultiplicativeExpression.BinaryExpression_1_0 returns Reference | ||
| 1208 | * ExponentialExpression returns Reference | ||
| 1209 | * ExponentialExpression.BinaryExpression_1_0 returns Reference | ||
| 1210 | * UnaryExpression returns Reference | ||
| 1211 | * AggregationExpression returns Reference | ||
| 1212 | * AtomicExpression returns Reference | ||
| 1213 | * Reference returns Reference | ||
| 703 | * | 1214 | * |
| 704 | * Constraint: | 1215 | * Constraint: |
| 705 | * {True} | 1216 | * referred=[NamedElement|QualifiedName] |
| 706 | */ | 1217 | */ |
| 707 | protected void sequence_TruthValue(ISerializationContext context, True semanticObject) { | 1218 | protected void sequence_Reference(ISerializationContext context, Reference semanticObject) { |
| 708 | genericSequencer.createSequence(context, semanticObject); | 1219 | if (errorAcceptor != null) { |
| 1220 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED) == ValueTransient.YES) | ||
| 1221 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED)); | ||
| 1222 | } | ||
| 1223 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1224 | feeder.accept(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.REFERENCE__REFERRED, false)); | ||
| 1225 | feeder.finish(); | ||
| 709 | } | 1226 | } |
| 710 | 1227 | ||
| 711 | 1228 | ||
| 712 | /** | 1229 | /** |
| 713 | * Contexts: | 1230 | * Contexts: |
| 714 | * TruthValue returns Unknown | 1231 | * Argument returns StarArgument |
| 1232 | * StarArgument returns StarArgument | ||
| 715 | * | 1233 | * |
| 716 | * Constraint: | 1234 | * Constraint: |
| 717 | * {Unknown} | 1235 | * {StarArgument} |
| 718 | */ | 1236 | */ |
| 719 | protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) { | 1237 | protected void sequence_StarArgument(ISerializationContext context, StarArgument semanticObject) { |
| 720 | genericSequencer.createSequence(context, semanticObject); | 1238 | genericSequencer.createSequence(context, semanticObject); |
| 721 | } | 1239 | } |
| 722 | 1240 | ||
| 723 | 1241 | ||
| 724 | /** | 1242 | /** |
| 725 | * Contexts: | 1243 | * Contexts: |
| 726 | * ComplexObject returns UnnamedObject | 1244 | * AssertionOrDefinition.Assertion_1_0_0 returns StringLiteral |
| 727 | * Object returns UnnamedObject | 1245 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral |
| 728 | * UnnamedObject returns UnnamedObject | 1246 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns StringLiteral |
| 1247 | * Expression returns StringLiteral | ||
| 1248 | * DisjunctiveExpression returns StringLiteral | ||
| 1249 | * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral | ||
| 1250 | * DisjunctiveExpression.Case_1_1_0 returns StringLiteral | ||
| 1251 | * ConjunctiveExpression returns StringLiteral | ||
| 1252 | * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral | ||
| 1253 | * ComparisonExpression returns StringLiteral | ||
| 1254 | * ComparisonExpression.Comparison_1_0 returns StringLiteral | ||
| 1255 | * AdditiveExpression returns StringLiteral | ||
| 1256 | * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral | ||
| 1257 | * MultiplicativeExpression returns StringLiteral | ||
| 1258 | * MultiplicativeExpression.BinaryExpression_1_0 returns StringLiteral | ||
| 1259 | * ExponentialExpression returns StringLiteral | ||
| 1260 | * ExponentialExpression.BinaryExpression_1_0 returns StringLiteral | ||
| 1261 | * UnaryExpression returns StringLiteral | ||
| 1262 | * AggregationExpression returns StringLiteral | ||
| 1263 | * AtomicExpression returns StringLiteral | ||
| 1264 | * Literal returns StringLiteral | ||
| 1265 | * StringLiteral returns StringLiteral | ||
| 1266 | * | ||
| 1267 | * Constraint: | ||
| 1268 | * value=STRING | ||
| 1269 | */ | ||
| 1270 | protected void sequence_StringLiteral(ISerializationContext context, StringLiteral semanticObject) { | ||
| 1271 | if (errorAcceptor != null) { | ||
| 1272 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES) | ||
| 1273 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE)); | ||
| 1274 | } | ||
| 1275 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1276 | feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); | ||
| 1277 | feeder.finish(); | ||
| 1278 | } | ||
| 1279 | |||
| 1280 | |||
| 1281 | /** | ||
| 1282 | * Contexts: | ||
| 1283 | * Argument returns TypedArgument | ||
| 1284 | * TypedArgument returns TypedArgument | ||
| 1285 | * | ||
| 1286 | * Constraint: | ||
| 1287 | * (type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName]) | ||
| 1288 | */ | ||
| 1289 | protected void sequence_TypedArgument(ISerializationContext context, TypedArgument semanticObject) { | ||
| 1290 | if (errorAcceptor != null) { | ||
| 1291 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE) == ValueTransient.YES) | ||
| 1292 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE)); | ||
| 1293 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE) == ValueTransient.YES) | ||
| 1294 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE)); | ||
| 1295 | } | ||
| 1296 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1297 | feeder.accept(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE, false)); | ||
| 1298 | feeder.accept(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE, false)); | ||
| 1299 | feeder.finish(); | ||
| 1300 | } | ||
| 1301 | |||
| 1302 | |||
| 1303 | /** | ||
| 1304 | * Contexts: | ||
| 1305 | * Argument returns TypedStarArgument | ||
| 1306 | * TypedStarArgument returns TypedStarArgument | ||
| 1307 | * | ||
| 1308 | * Constraint: | ||
| 1309 | * type=[NamedElement|QualifiedName] | ||
| 1310 | */ | ||
| 1311 | protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) { | ||
| 1312 | if (errorAcceptor != null) { | ||
| 1313 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE) == ValueTransient.YES) | ||
| 1314 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE)); | ||
| 1315 | } | ||
| 1316 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
| 1317 | feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE, false)); | ||
| 1318 | feeder.finish(); | ||
| 1319 | } | ||
| 1320 | |||
| 1321 | |||
| 1322 | /** | ||
| 1323 | * Contexts: | ||
| 1324 | * AssertionOrDefinition.Assertion_1_0_0 returns UnaryExpression | ||
| 1325 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression | ||
| 1326 | * AssertionOrDefinition.MetricDefinition_1_2_0 returns UnaryExpression | ||
| 1327 | * Expression returns UnaryExpression | ||
| 1328 | * DisjunctiveExpression returns UnaryExpression | ||
| 1329 | * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression | ||
| 1330 | * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression | ||
| 1331 | * ConjunctiveExpression returns UnaryExpression | ||
| 1332 | * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression | ||
| 1333 | * ComparisonExpression returns UnaryExpression | ||
| 1334 | * ComparisonExpression.Comparison_1_0 returns UnaryExpression | ||
| 1335 | * AdditiveExpression returns UnaryExpression | ||
| 1336 | * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression | ||
| 1337 | * MultiplicativeExpression returns UnaryExpression | ||
| 1338 | * MultiplicativeExpression.BinaryExpression_1_0 returns UnaryExpression | ||
| 1339 | * ExponentialExpression returns UnaryExpression | ||
| 1340 | * ExponentialExpression.BinaryExpression_1_0 returns UnaryExpression | ||
| 1341 | * UnaryExpression returns UnaryExpression | ||
| 1342 | * AggregationExpression returns UnaryExpression | ||
| 1343 | * AtomicExpression returns UnaryExpression | ||
| 729 | * | 1344 | * |
| 730 | * Constraint: | 1345 | * Constraint: |
| 731 | * name=ID | 1346 | * (op=UnaryOp body=AggregationExpression) |
| 732 | */ | 1347 | */ |
| 733 | protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) { | 1348 | protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) { |
| 734 | if (errorAcceptor != null) { | 1349 | if (errorAcceptor != null) { |
| 735 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES) | 1350 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP) == ValueTransient.YES) |
| 736 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME)); | 1351 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP)); |
| 1352 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY) == ValueTransient.YES) | ||
| 1353 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY)); | ||
| 737 | } | 1354 | } |
| 738 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1355 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 739 | feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 1356 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0(), semanticObject.getOp()); |
| 1357 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0(), semanticObject.getBody()); | ||
| 740 | feeder.finish(); | 1358 | feeder.finish(); |
| 741 | } | 1359 | } |
| 742 | 1360 | ||
| 743 | 1361 | ||
| 744 | /** | 1362 | /** |
| 745 | * Contexts: | 1363 | * Contexts: |
| 746 | * Literal returns Variable | 1364 | * Statement returns UnnamedErrorPrediateDefinition |
| 747 | * Variable returns Variable | 1365 | * UnnamedErrorPrediateDefinition returns UnnamedErrorPrediateDefinition |
| 748 | * | 1366 | * |
| 749 | * Constraint: | 1367 | * Constraint: |
| 750 | * name=ID | 1368 | * (argumentList=ArgumentList body=Expression) |
| 751 | */ | 1369 | */ |
| 752 | protected void sequence_Variable(ISerializationContext context, Variable semanticObject) { | 1370 | protected void sequence_UnnamedErrorPrediateDefinition(ISerializationContext context, UnnamedErrorPrediateDefinition semanticObject) { |
| 753 | if (errorAcceptor != null) { | 1371 | if (errorAcceptor != null) { |
| 754 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES) | 1372 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES) |
| 755 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME)); | 1373 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST)); |
| 1374 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY) == ValueTransient.YES) | ||
| 1375 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY)); | ||
| 756 | } | 1376 | } |
| 757 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | 1377 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); |
| 758 | feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | 1378 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); |
| 1379 | feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
| 759 | feeder.finish(); | 1380 | feeder.finish(); |
| 760 | } | 1381 | } |
| 761 | 1382 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java index 8a2d6f62..1fa1a820 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.serializer; | 4 | package org.eclipse.viatra.solver.language.serializer; |
| 5 | 5 | ||
| @@ -11,7 +11,6 @@ import org.eclipse.xtext.IGrammarAccess; | |||
| 11 | import org.eclipse.xtext.RuleCall; | 11 | import org.eclipse.xtext.RuleCall; |
| 12 | import org.eclipse.xtext.nodemodel.INode; | 12 | import org.eclipse.xtext.nodemodel.INode; |
| 13 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; | 13 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; |
| 14 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias; | ||
| 15 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; | 14 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; |
| 16 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; | 15 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; |
| 17 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; | 16 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; |
| @@ -21,25 +20,46 @@ import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer; | |||
| 21 | public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer { | 20 | public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer { |
| 22 | 21 | ||
| 23 | protected SolverLanguageGrammarAccess grammarAccess; | 22 | protected SolverLanguageGrammarAccess grammarAccess; |
| 24 | protected AbstractElementAlias match_BasicInterpretation___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q; | 23 | protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_a; |
| 25 | protected AbstractElementAlias match_Constraint___LeftParenthesisKeyword_0_2_0_RightParenthesisKeyword_0_2_3__q; | 24 | protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_p; |
| 26 | protected AbstractElementAlias match_PatternBody_TrueKeyword_1_0_q; | 25 | protected AbstractElementAlias match_MemberDefinition_SemicolonKeyword_5_q; |
| 27 | protected AbstractElementAlias match_Predicate___LeftParenthesisKeyword_2_0_RightParenthesisKeyword_2_2__q; | ||
| 28 | 26 | ||
| 29 | @Inject | 27 | @Inject |
| 30 | protected void init(IGrammarAccess access) { | 28 | protected void init(IGrammarAccess access) { |
| 31 | grammarAccess = (SolverLanguageGrammarAccess) access; | 29 | grammarAccess = (SolverLanguageGrammarAccess) access; |
| 32 | match_BasicInterpretation___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()), new TokenAlias(false, false, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2())); | 30 | match_AtomicExpression_LeftParenthesisKeyword_4_0_a = new TokenAlias(true, true, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
| 33 | match_Constraint___LeftParenthesisKeyword_0_2_0_RightParenthesisKeyword_0_2_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()), new TokenAlias(false, false, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3())); | 31 | match_AtomicExpression_LeftParenthesisKeyword_4_0_p = new TokenAlias(true, false, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
| 34 | match_PatternBody_TrueKeyword_1_0_q = new TokenAlias(false, true, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); | 32 | match_MemberDefinition_SemicolonKeyword_5_q = new TokenAlias(false, true, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); |
| 35 | match_Predicate___LeftParenthesisKeyword_2_0_RightParenthesisKeyword_2_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()), new TokenAlias(false, false, grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2())); | ||
| 36 | } | 33 | } |
| 37 | 34 | ||
| 38 | @Override | 35 | @Override |
| 39 | protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { | 36 | protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { |
| 37 | if (ruleCall.getRule() == grammarAccess.getFULL_STOPRule()) | ||
| 38 | return getFULL_STOPToken(semanticObject, ruleCall, node); | ||
| 39 | else if (ruleCall.getRule() == grammarAccess.getREFLEXIVE_TRANSITIVE_CLOSURERule()) | ||
| 40 | return getREFLEXIVE_TRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node); | ||
| 41 | else if (ruleCall.getRule() == grammarAccess.getTRANSITIVE_CLOSURERule()) | ||
| 42 | return getTRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node); | ||
| 40 | return ""; | 43 | return ""; |
| 41 | } | 44 | } |
| 42 | 45 | ||
| 46 | /** | ||
| 47 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
| 48 | * Defaults to the empty string. | ||
| 49 | */ | ||
| 50 | protected String getFULL_STOPToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
| 51 | |||
| 52 | /** | ||
| 53 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
| 54 | * Defaults to the empty string. | ||
| 55 | */ | ||
| 56 | protected String getREFLEXIVE_TRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
| 57 | |||
| 58 | /** | ||
| 59 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
| 60 | * Defaults to the empty string. | ||
| 61 | */ | ||
| 62 | protected String getTRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
| 43 | 63 | ||
| 44 | @Override | 64 | @Override |
| 45 | protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { | 65 | protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { |
| @@ -47,60 +67,71 @@ public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer | |||
| 47 | List<INode> transitionNodes = collectNodes(fromNode, toNode); | 67 | List<INode> transitionNodes = collectNodes(fromNode, toNode); |
| 48 | for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { | 68 | for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { |
| 49 | List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax); | 69 | List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax); |
| 50 | if (match_BasicInterpretation___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q.equals(syntax)) | 70 | if (match_AtomicExpression_LeftParenthesisKeyword_4_0_a.equals(syntax)) |
| 51 | emit_BasicInterpretation___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q(semanticObject, getLastNavigableState(), syntaxNodes); | 71 | emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(semanticObject, getLastNavigableState(), syntaxNodes); |
| 52 | else if (match_Constraint___LeftParenthesisKeyword_0_2_0_RightParenthesisKeyword_0_2_3__q.equals(syntax)) | 72 | else if (match_AtomicExpression_LeftParenthesisKeyword_4_0_p.equals(syntax)) |
| 53 | emit_Constraint___LeftParenthesisKeyword_0_2_0_RightParenthesisKeyword_0_2_3__q(semanticObject, getLastNavigableState(), syntaxNodes); | 73 | emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(semanticObject, getLastNavigableState(), syntaxNodes); |
| 54 | else if (match_PatternBody_TrueKeyword_1_0_q.equals(syntax)) | 74 | else if (match_MemberDefinition_SemicolonKeyword_5_q.equals(syntax)) |
| 55 | emit_PatternBody_TrueKeyword_1_0_q(semanticObject, getLastNavigableState(), syntaxNodes); | 75 | emit_MemberDefinition_SemicolonKeyword_5_q(semanticObject, getLastNavigableState(), syntaxNodes); |
| 56 | else if (match_Predicate___LeftParenthesisKeyword_2_0_RightParenthesisKeyword_2_2__q.equals(syntax)) | ||
| 57 | emit_Predicate___LeftParenthesisKeyword_2_0_RightParenthesisKeyword_2_2__q(semanticObject, getLastNavigableState(), syntaxNodes); | ||
| 58 | else acceptNodes(getLastNavigableState(), syntaxNodes); | 76 | else acceptNodes(getLastNavigableState(), syntaxNodes); |
| 59 | } | 77 | } |
| 60 | } | 78 | } |
| 61 | 79 | ||
| 62 | /** | 80 | /** |
| 63 | * Ambiguous syntax: | 81 | * Ambiguous syntax: |
| 64 | * ('(' ')')? | 82 | * '('* |
| 65 | * | ||
| 66 | * This ambiguous syntax occurs at: | ||
| 67 | * symbol=Symbol (ambiguity) ':' value=TruthValue | ||
| 68 | */ | ||
| 69 | protected void emit_BasicInterpretation___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
| 70 | acceptNodes(transition, nodes); | ||
| 71 | } | ||
| 72 | |||
| 73 | /** | ||
| 74 | * Ambiguous syntax: | ||
| 75 | * ('(' ')')? | ||
| 76 | * | 83 | * |
| 77 | * This ambiguous syntax occurs at: | 84 | * This ambiguous syntax occurs at: |
| 78 | * symbol=ModelSymbol (ambiguity) (rule end) | 85 | * (rule start) (ambiguity) '[' lowerBound=Expression |
| 86 | * (rule start) (ambiguity) 'count' '{' body=Expression | ||
| 87 | * (rule start) (ambiguity) 'empty' (rule start) | ||
| 88 | * (rule start) (ambiguity) 'if' condition=Expression | ||
| 89 | * (rule start) (ambiguity) 'inf' (rule start) | ||
| 90 | * (rule start) (ambiguity) functor=Reference | ||
| 91 | * (rule start) (ambiguity) op=AggregationOp | ||
| 92 | * (rule start) (ambiguity) op=UnaryOp | ||
| 93 | * (rule start) (ambiguity) referred=[NamedElement|QualifiedName] | ||
| 94 | * (rule start) (ambiguity) value=LogicValue | ||
| 95 | * (rule start) (ambiguity) value=Real | ||
| 96 | * (rule start) (ambiguity) value=STRING | ||
| 97 | * (rule start) (ambiguity) {BinaryExpression.left=} | ||
| 98 | * (rule start) (ambiguity) {Comparison.left=} | ||
| 99 | * (rule start) (ambiguity) {Conjunction.children+=} | ||
| 100 | * (rule start) (ambiguity) {Disjunction.children+=} | ||
| 101 | * (rule start) (ambiguity) {Switch.cases+=} | ||
| 79 | */ | 102 | */ |
| 80 | protected void emit_Constraint___LeftParenthesisKeyword_0_2_0_RightParenthesisKeyword_0_2_3__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | 103 | protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { |
| 81 | acceptNodes(transition, nodes); | 104 | acceptNodes(transition, nodes); |
| 82 | } | 105 | } |
| 83 | 106 | ||
| 84 | /** | 107 | /** |
| 85 | * Ambiguous syntax: | 108 | * Ambiguous syntax: |
| 86 | * 'true'? | 109 | * '('+ |
| 87 | * | 110 | * |
| 88 | * This ambiguous syntax occurs at: | 111 | * This ambiguous syntax occurs at: |
| 89 | * (rule start) (ambiguity) (rule start) | 112 | * (rule start) (ambiguity) 'count' '{' body=Expression |
| 113 | * (rule start) (ambiguity) 'if' condition=Expression | ||
| 114 | * (rule start) (ambiguity) op=AggregationOp | ||
| 115 | * (rule start) (ambiguity) op=UnaryOp | ||
| 116 | * (rule start) (ambiguity) {BinaryExpression.left=} | ||
| 117 | * (rule start) (ambiguity) {Comparison.left=} | ||
| 118 | * (rule start) (ambiguity) {Conjunction.children+=} | ||
| 119 | * (rule start) (ambiguity) {Disjunction.children+=} | ||
| 120 | * (rule start) (ambiguity) {Switch.cases+=} | ||
| 90 | */ | 121 | */ |
| 91 | protected void emit_PatternBody_TrueKeyword_1_0_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | 122 | protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { |
| 92 | acceptNodes(transition, nodes); | 123 | acceptNodes(transition, nodes); |
| 93 | } | 124 | } |
| 94 | 125 | ||
| 95 | /** | 126 | /** |
| 96 | * Ambiguous syntax: | 127 | * Ambiguous syntax: |
| 97 | * ('(' ')')? | 128 | * ';'? |
| 98 | * | 129 | * |
| 99 | * This ambiguous syntax occurs at: | 130 | * This ambiguous syntax occurs at: |
| 100 | * symbol=ModelSymbol (ambiguity) ':-' 'false' '.' (rule end) | 131 | * name=ID (ambiguity) (rule end) |
| 101 | * symbol=ModelSymbol (ambiguity) ':-' bodies+=PatternBody | 132 | * opposite=[NamedElement|QualifiedName] (ambiguity) (rule end) |
| 102 | */ | 133 | */ |
| 103 | protected void emit_Predicate___LeftParenthesisKeyword_2_0_RightParenthesisKeyword_2_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | 134 | protected void emit_MemberDefinition_SemicolonKeyword_5_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { |
| 104 | acceptNodes(transition, nodes); | 135 | acceptNodes(transition, nodes); |
| 105 | } | 136 | } |
| 106 | 137 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java index e6a8f1d9..0252938a 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.services; | 4 | package org.eclipse.viatra.solver.language.services; |
| 5 | 5 | ||
| @@ -9,6 +9,9 @@ import java.util.List; | |||
| 9 | import org.eclipse.xtext.Action; | 9 | import org.eclipse.xtext.Action; |
| 10 | import org.eclipse.xtext.Alternatives; | 10 | import org.eclipse.xtext.Alternatives; |
| 11 | import org.eclipse.xtext.Assignment; | 11 | import org.eclipse.xtext.Assignment; |
| 12 | import org.eclipse.xtext.CrossReference; | ||
| 13 | import org.eclipse.xtext.EnumLiteralDeclaration; | ||
| 14 | import org.eclipse.xtext.EnumRule; | ||
| 12 | import org.eclipse.xtext.Grammar; | 15 | import org.eclipse.xtext.Grammar; |
| 13 | import org.eclipse.xtext.GrammarUtil; | 16 | import org.eclipse.xtext.GrammarUtil; |
| 14 | import org.eclipse.xtext.Group; | 17 | import org.eclipse.xtext.Group; |
| @@ -17,6 +20,7 @@ import org.eclipse.xtext.ParserRule; | |||
| 17 | import org.eclipse.xtext.RuleCall; | 20 | import org.eclipse.xtext.RuleCall; |
| 18 | import org.eclipse.xtext.TerminalRule; | 21 | import org.eclipse.xtext.TerminalRule; |
| 19 | import org.eclipse.xtext.common.services.TerminalsGrammarAccess; | 22 | import org.eclipse.xtext.common.services.TerminalsGrammarAccess; |
| 23 | import org.eclipse.xtext.service.AbstractElementFinder.AbstractEnumRuleElementFinder; | ||
| 20 | import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; | 24 | import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; |
| 21 | import org.eclipse.xtext.service.GrammarProvider; | 25 | import org.eclipse.xtext.service.GrammarProvider; |
| 22 | 26 | ||
| @@ -40,624 +44,1340 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 40 | } | 44 | } |
| 41 | public class StatementElements extends AbstractParserRuleElementFinder { | 45 | public class StatementElements extends AbstractParserRuleElementFinder { |
| 42 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | 46 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); |
| 43 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 47 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 44 | private final RuleCall cInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 48 | private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); |
| 45 | private final RuleCall cPredicateParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 49 | private final RuleCall cAssertionOrDefinitionParserRuleCall_0_0 = (RuleCall)cAlternatives_0.eContents().get(0); |
| 50 | private final RuleCall cPredicateDefinitionParserRuleCall_0_1 = (RuleCall)cAlternatives_0.eContents().get(1); | ||
| 51 | private final RuleCall cUnnamedErrorPrediateDefinitionParserRuleCall_0_2 = (RuleCall)cAlternatives_0.eContents().get(2); | ||
| 52 | private final RuleCall cDefaultDefinitionParserRuleCall_0_3 = (RuleCall)cAlternatives_0.eContents().get(3); | ||
| 53 | private final RuleCall cExternPredicateDefinitionParserRuleCall_0_4 = (RuleCall)cAlternatives_0.eContents().get(4); | ||
| 54 | private final RuleCall cMetricDefinitionParserRuleCall_0_5 = (RuleCall)cAlternatives_0.eContents().get(5); | ||
| 55 | private final RuleCall cExternMetricDefinitionParserRuleCall_0_6 = (RuleCall)cAlternatives_0.eContents().get(6); | ||
| 56 | private final RuleCall cClassDefinitionParserRuleCall_0_7 = (RuleCall)cAlternatives_0.eContents().get(7); | ||
| 57 | private final RuleCall cScopeDefinitionParserRuleCall_0_8 = (RuleCall)cAlternatives_0.eContents().get(8); | ||
| 58 | private final RuleCall cObjectiveDefinitionParserRuleCall_0_9 = (RuleCall)cAlternatives_0.eContents().get(9); | ||
| 59 | private final RuleCall cFULL_STOPTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); | ||
| 46 | 60 | ||
| 47 | //Statement: | 61 | //Statement: |
| 48 | // Interpretation | Predicate; | 62 | // (AssertionOrDefinition | PredicateDefinition | UnnamedErrorPrediateDefinition | DefaultDefinition | |
| 63 | // ExternPredicateDefinition | MetricDefinition | ExternMetricDefinition | ClassDefinition | ScopeDefinition | | ||
| 64 | // ObjectiveDefinition) FULL_STOP; | ||
| 49 | @Override public ParserRule getRule() { return rule; } | 65 | @Override public ParserRule getRule() { return rule; } |
| 50 | 66 | ||
| 51 | //Interpretation | Predicate | 67 | //(AssertionOrDefinition | PredicateDefinition | UnnamedErrorPrediateDefinition | DefaultDefinition | |
| 52 | public Alternatives getAlternatives() { return cAlternatives; } | 68 | //ExternPredicateDefinition | MetricDefinition | ExternMetricDefinition | ClassDefinition | ScopeDefinition | |
| 69 | //ObjectiveDefinition) FULL_STOP | ||
| 70 | public Group getGroup() { return cGroup; } | ||
| 71 | |||
| 72 | //(AssertionOrDefinition | PredicateDefinition | UnnamedErrorPrediateDefinition | DefaultDefinition | | ||
| 73 | //ExternPredicateDefinition | MetricDefinition | ExternMetricDefinition | ClassDefinition | ScopeDefinition | | ||
| 74 | //ObjectiveDefinition) | ||
| 75 | public Alternatives getAlternatives_0() { return cAlternatives_0; } | ||
| 76 | |||
| 77 | //AssertionOrDefinition | ||
| 78 | public RuleCall getAssertionOrDefinitionParserRuleCall_0_0() { return cAssertionOrDefinitionParserRuleCall_0_0; } | ||
| 79 | |||
| 80 | //PredicateDefinition | ||
| 81 | public RuleCall getPredicateDefinitionParserRuleCall_0_1() { return cPredicateDefinitionParserRuleCall_0_1; } | ||
| 82 | |||
| 83 | //UnnamedErrorPrediateDefinition | ||
| 84 | public RuleCall getUnnamedErrorPrediateDefinitionParserRuleCall_0_2() { return cUnnamedErrorPrediateDefinitionParserRuleCall_0_2; } | ||
| 85 | |||
| 86 | //DefaultDefinition | ||
| 87 | public RuleCall getDefaultDefinitionParserRuleCall_0_3() { return cDefaultDefinitionParserRuleCall_0_3; } | ||
| 88 | |||
| 89 | //ExternPredicateDefinition | ||
| 90 | public RuleCall getExternPredicateDefinitionParserRuleCall_0_4() { return cExternPredicateDefinitionParserRuleCall_0_4; } | ||
| 91 | |||
| 92 | //MetricDefinition | ||
| 93 | public RuleCall getMetricDefinitionParserRuleCall_0_5() { return cMetricDefinitionParserRuleCall_0_5; } | ||
| 53 | 94 | ||
| 54 | //Interpretation | 95 | //ExternMetricDefinition |
| 55 | public RuleCall getInterpretationParserRuleCall_0() { return cInterpretationParserRuleCall_0; } | 96 | public RuleCall getExternMetricDefinitionParserRuleCall_0_6() { return cExternMetricDefinitionParserRuleCall_0_6; } |
| 56 | 97 | ||
| 57 | //Predicate | 98 | //ClassDefinition |
| 58 | public RuleCall getPredicateParserRuleCall_1() { return cPredicateParserRuleCall_1; } | 99 | public RuleCall getClassDefinitionParserRuleCall_0_7() { return cClassDefinitionParserRuleCall_0_7; } |
| 100 | |||
| 101 | //ScopeDefinition | ||
| 102 | public RuleCall getScopeDefinitionParserRuleCall_0_8() { return cScopeDefinitionParserRuleCall_0_8; } | ||
| 103 | |||
| 104 | //ObjectiveDefinition | ||
| 105 | public RuleCall getObjectiveDefinitionParserRuleCall_0_9() { return cObjectiveDefinitionParserRuleCall_0_9; } | ||
| 106 | |||
| 107 | //FULL_STOP | ||
| 108 | public RuleCall getFULL_STOPTerminalRuleCall_1() { return cFULL_STOPTerminalRuleCall_1; } | ||
| 59 | } | 109 | } |
| 60 | public class REALLiteralElements extends AbstractParserRuleElementFinder { | 110 | public class AssertionOrDefinitionElements extends AbstractParserRuleElementFinder { |
| 61 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); | 111 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AssertionOrDefinition"); |
| 62 | private final Group cGroup = (Group)rule.eContents().get(1); | 112 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 63 | private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); | 113 | private final RuleCall cExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); |
| 64 | private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); | 114 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); |
| 65 | private final Keyword cFullStopKeyword_2 = (Keyword)cGroup.eContents().get(2); | 115 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); |
| 66 | private final RuleCall cINTTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); | 116 | private final Action cAssertionBodyAction_1_0_0 = (Action)cGroup_1_0.eContents().get(0); |
| 117 | private final Group cGroup_1_0_1 = (Group)cGroup_1_0.eContents().get(1); | ||
| 118 | private final Keyword cColonKeyword_1_0_1_0 = (Keyword)cGroup_1_0_1.eContents().get(0); | ||
| 119 | private final Assignment cRangeAssignment_1_0_1_1 = (Assignment)cGroup_1_0_1.eContents().get(1); | ||
| 120 | private final RuleCall cRangeExpressionParserRuleCall_1_0_1_1_0 = (RuleCall)cRangeAssignment_1_0_1_1.eContents().get(0); | ||
| 121 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
| 122 | private final Action cPredicateDefinitionHeadAction_1_1_0 = (Action)cGroup_1_1.eContents().get(0); | ||
| 123 | private final Keyword cColonHyphenMinusKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
| 124 | private final Assignment cBodyAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
| 125 | private final RuleCall cBodyExpressionParserRuleCall_1_1_2_0 = (RuleCall)cBodyAssignment_1_1_2.eContents().get(0); | ||
| 126 | private final Group cGroup_1_2 = (Group)cAlternatives_1.eContents().get(2); | ||
| 127 | private final Action cMetricDefinitionHeadAction_1_2_0 = (Action)cGroup_1_2.eContents().get(0); | ||
| 128 | private final Keyword cEqualsSignKeyword_1_2_1 = (Keyword)cGroup_1_2.eContents().get(1); | ||
| 129 | private final Assignment cBodyAssignment_1_2_2 = (Assignment)cGroup_1_2.eContents().get(2); | ||
| 130 | private final RuleCall cBodyExpressionParserRuleCall_1_2_2_0 = (RuleCall)cBodyAssignment_1_2_2.eContents().get(0); | ||
| 131 | |||
| 132 | //AssertionOrDefinition Statement: | ||
| 133 | // Expression ({Assertion.body=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" | ||
| 134 | // body=Expression | {MetricDefinition.head=current} "=" body=Expression); | ||
| 135 | @Override public ParserRule getRule() { return rule; } | ||
| 136 | |||
| 137 | //Expression ({Assertion.body=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" body=Expression | | ||
| 138 | //{MetricDefinition.head=current} "=" body=Expression) | ||
| 139 | public Group getGroup() { return cGroup; } | ||
| 140 | |||
| 141 | //Expression | ||
| 142 | public RuleCall getExpressionParserRuleCall_0() { return cExpressionParserRuleCall_0; } | ||
| 143 | |||
| 144 | //({Assertion.body=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" body=Expression | | ||
| 145 | //{MetricDefinition.head=current} "=" body=Expression) | ||
| 146 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
| 67 | 147 | ||
| 68 | //REALLiteral ecore::EBigDecimal: | 148 | //{Assertion.body=current} (":" range=Expression)? |
| 69 | // '-'? INT '.' INT; | 149 | public Group getGroup_1_0() { return cGroup_1_0; } |
| 150 | |||
| 151 | //{Assertion.body=current} | ||
| 152 | public Action getAssertionBodyAction_1_0_0() { return cAssertionBodyAction_1_0_0; } | ||
| 153 | |||
| 154 | //(":" range=Expression)? | ||
| 155 | public Group getGroup_1_0_1() { return cGroup_1_0_1; } | ||
| 156 | |||
| 157 | //":" | ||
| 158 | public Keyword getColonKeyword_1_0_1_0() { return cColonKeyword_1_0_1_0; } | ||
| 159 | |||
| 160 | //range=Expression | ||
| 161 | public Assignment getRangeAssignment_1_0_1_1() { return cRangeAssignment_1_0_1_1; } | ||
| 162 | |||
| 163 | //Expression | ||
| 164 | public RuleCall getRangeExpressionParserRuleCall_1_0_1_1_0() { return cRangeExpressionParserRuleCall_1_0_1_1_0; } | ||
| 165 | |||
| 166 | //{PredicateDefinition.head=current} ":-" body=Expression | ||
| 167 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
| 168 | |||
| 169 | //{PredicateDefinition.head=current} | ||
| 170 | public Action getPredicateDefinitionHeadAction_1_1_0() { return cPredicateDefinitionHeadAction_1_1_0; } | ||
| 171 | |||
| 172 | //":-" | ||
| 173 | public Keyword getColonHyphenMinusKeyword_1_1_1() { return cColonHyphenMinusKeyword_1_1_1; } | ||
| 174 | |||
| 175 | //body=Expression | ||
| 176 | public Assignment getBodyAssignment_1_1_2() { return cBodyAssignment_1_1_2; } | ||
| 177 | |||
| 178 | //Expression | ||
| 179 | public RuleCall getBodyExpressionParserRuleCall_1_1_2_0() { return cBodyExpressionParserRuleCall_1_1_2_0; } | ||
| 180 | |||
| 181 | //{MetricDefinition.head=current} "=" body=Expression | ||
| 182 | public Group getGroup_1_2() { return cGroup_1_2; } | ||
| 183 | |||
| 184 | //{MetricDefinition.head=current} | ||
| 185 | public Action getMetricDefinitionHeadAction_1_2_0() { return cMetricDefinitionHeadAction_1_2_0; } | ||
| 186 | |||
| 187 | //"=" | ||
| 188 | public Keyword getEqualsSignKeyword_1_2_1() { return cEqualsSignKeyword_1_2_1; } | ||
| 189 | |||
| 190 | //body=Expression | ||
| 191 | public Assignment getBodyAssignment_1_2_2() { return cBodyAssignment_1_2_2; } | ||
| 192 | |||
| 193 | //Expression | ||
| 194 | public RuleCall getBodyExpressionParserRuleCall_1_2_2_0() { return cBodyExpressionParserRuleCall_1_2_2_0; } | ||
| 195 | } | ||
| 196 | public class PredicateDefinitionElements extends AbstractParserRuleElementFinder { | ||
| 197 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PredicateDefinition"); | ||
| 198 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 199 | private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); | ||
| 200 | private final Group cGroup_0_0 = (Group)cAlternatives_0.eContents().get(0); | ||
| 201 | private final Assignment cFunctionalAssignment_0_0_0 = (Assignment)cGroup_0_0.eContents().get(0); | ||
| 202 | private final Keyword cFunctionalFunctionalKeyword_0_0_0_0 = (Keyword)cFunctionalAssignment_0_0_0.eContents().get(0); | ||
| 203 | private final Assignment cErrorAssignment_0_0_1 = (Assignment)cGroup_0_0.eContents().get(1); | ||
| 204 | private final Keyword cErrorErrorKeyword_0_0_1_0 = (Keyword)cErrorAssignment_0_0_1.eContents().get(0); | ||
| 205 | private final Group cGroup_0_1 = (Group)cAlternatives_0.eContents().get(1); | ||
| 206 | private final Assignment cErrorAssignment_0_1_0 = (Assignment)cGroup_0_1.eContents().get(0); | ||
| 207 | private final Keyword cErrorErrorKeyword_0_1_0_0 = (Keyword)cErrorAssignment_0_1_0.eContents().get(0); | ||
| 208 | private final Assignment cFunctionalAssignment_0_1_1 = (Assignment)cGroup_0_1.eContents().get(1); | ||
| 209 | private final Keyword cFunctionalFunctionalKeyword_0_1_1_0 = (Keyword)cFunctionalAssignment_0_1_1.eContents().get(0); | ||
| 210 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 211 | private final RuleCall cHeadCallParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); | ||
| 212 | private final Keyword cColonHyphenMinusKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 213 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 214 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
| 215 | |||
| 216 | //PredicateDefinition: | ||
| 217 | // (functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression; | ||
| 70 | @Override public ParserRule getRule() { return rule; } | 218 | @Override public ParserRule getRule() { return rule; } |
| 71 | 219 | ||
| 72 | //'-'? INT '.' INT | 220 | //(functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression |
| 73 | public Group getGroup() { return cGroup; } | 221 | public Group getGroup() { return cGroup; } |
| 74 | 222 | ||
| 75 | //'-'? | 223 | //(functional?="functional" error?="error"? | error?="error" functional?="functional"?) |
| 76 | public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } | 224 | public Alternatives getAlternatives_0() { return cAlternatives_0; } |
| 77 | 225 | ||
| 78 | //INT | 226 | //functional?="functional" error?="error"? |
| 79 | public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } | 227 | public Group getGroup_0_0() { return cGroup_0_0; } |
| 80 | 228 | ||
| 81 | //'.' | 229 | //functional?="functional" |
| 82 | public Keyword getFullStopKeyword_2() { return cFullStopKeyword_2; } | 230 | public Assignment getFunctionalAssignment_0_0_0() { return cFunctionalAssignment_0_0_0; } |
| 83 | 231 | ||
| 84 | //INT | 232 | //"functional" |
| 85 | public RuleCall getINTTerminalRuleCall_3() { return cINTTerminalRuleCall_3; } | 233 | public Keyword getFunctionalFunctionalKeyword_0_0_0_0() { return cFunctionalFunctionalKeyword_0_0_0_0; } |
| 234 | |||
| 235 | //error?="error"? | ||
| 236 | public Assignment getErrorAssignment_0_0_1() { return cErrorAssignment_0_0_1; } | ||
| 237 | |||
| 238 | //"error" | ||
| 239 | public Keyword getErrorErrorKeyword_0_0_1_0() { return cErrorErrorKeyword_0_0_1_0; } | ||
| 240 | |||
| 241 | //error?="error" functional?="functional"? | ||
| 242 | public Group getGroup_0_1() { return cGroup_0_1; } | ||
| 243 | |||
| 244 | //error?="error" | ||
| 245 | public Assignment getErrorAssignment_0_1_0() { return cErrorAssignment_0_1_0; } | ||
| 246 | |||
| 247 | //"error" | ||
| 248 | public Keyword getErrorErrorKeyword_0_1_0_0() { return cErrorErrorKeyword_0_1_0_0; } | ||
| 249 | |||
| 250 | //functional?="functional"? | ||
| 251 | public Assignment getFunctionalAssignment_0_1_1() { return cFunctionalAssignment_0_1_1; } | ||
| 252 | |||
| 253 | //"functional" | ||
| 254 | public Keyword getFunctionalFunctionalKeyword_0_1_1_0() { return cFunctionalFunctionalKeyword_0_1_1_0; } | ||
| 255 | |||
| 256 | //head=Call | ||
| 257 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } | ||
| 258 | |||
| 259 | //Call | ||
| 260 | public RuleCall getHeadCallParserRuleCall_1_0() { return cHeadCallParserRuleCall_1_0; } | ||
| 261 | |||
| 262 | //":-" | ||
| 263 | public Keyword getColonHyphenMinusKeyword_2() { return cColonHyphenMinusKeyword_2; } | ||
| 264 | |||
| 265 | //body=Expression | ||
| 266 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } | ||
| 267 | |||
| 268 | //Expression | ||
| 269 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } | ||
| 270 | } | ||
| 271 | public class UnnamedErrorPrediateDefinitionElements extends AbstractParserRuleElementFinder { | ||
| 272 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnnamedErrorPrediateDefinition"); | ||
| 273 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 274 | private final Keyword cErrorKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
| 275 | private final Assignment cArgumentListAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 276 | private final RuleCall cArgumentListArgumentListParserRuleCall_1_0 = (RuleCall)cArgumentListAssignment_1.eContents().get(0); | ||
| 277 | private final Keyword cColonHyphenMinusKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 278 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 279 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
| 280 | |||
| 281 | //UnnamedErrorPrediateDefinition: | ||
| 282 | // "error" argumentList=ArgumentList ":-" body=Expression; | ||
| 283 | @Override public ParserRule getRule() { return rule; } | ||
| 284 | |||
| 285 | //"error" argumentList=ArgumentList ":-" body=Expression | ||
| 286 | public Group getGroup() { return cGroup; } | ||
| 287 | |||
| 288 | //"error" | ||
| 289 | public Keyword getErrorKeyword_0() { return cErrorKeyword_0; } | ||
| 290 | |||
| 291 | //argumentList=ArgumentList | ||
| 292 | public Assignment getArgumentListAssignment_1() { return cArgumentListAssignment_1; } | ||
| 293 | |||
| 294 | //ArgumentList | ||
| 295 | public RuleCall getArgumentListArgumentListParserRuleCall_1_0() { return cArgumentListArgumentListParserRuleCall_1_0; } | ||
| 296 | |||
| 297 | //":-" | ||
| 298 | public Keyword getColonHyphenMinusKeyword_2() { return cColonHyphenMinusKeyword_2; } | ||
| 299 | |||
| 300 | //body=Expression | ||
| 301 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } | ||
| 302 | |||
| 303 | //Expression | ||
| 304 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } | ||
| 86 | } | 305 | } |
| 87 | public class INTLiteralElements extends AbstractParserRuleElementFinder { | 306 | public class DefaultDefinitionElements extends AbstractParserRuleElementFinder { |
| 88 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); | 307 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DefaultDefinition"); |
| 89 | private final Group cGroup = (Group)rule.eContents().get(1); | 308 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 90 | private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); | 309 | private final Keyword cDefaultKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 91 | private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); | 310 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 311 | private final RuleCall cHeadCallParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); | ||
| 312 | private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 313 | private final Assignment cRangeAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 314 | private final RuleCall cRangeExpressionParserRuleCall_3_0 = (RuleCall)cRangeAssignment_3.eContents().get(0); | ||
| 92 | 315 | ||
| 93 | //INTLiteral ecore::EInt: | 316 | //DefaultDefinition: |
| 94 | // '-'? INT; | 317 | // "default" head=Call ":" range=Expression; |
| 95 | @Override public ParserRule getRule() { return rule; } | 318 | @Override public ParserRule getRule() { return rule; } |
| 96 | 319 | ||
| 97 | //'-'? INT | 320 | //"default" head=Call ":" range=Expression |
| 98 | public Group getGroup() { return cGroup; } | 321 | public Group getGroup() { return cGroup; } |
| 99 | 322 | ||
| 100 | //'-'? | 323 | //"default" |
| 101 | public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } | 324 | public Keyword getDefaultKeyword_0() { return cDefaultKeyword_0; } |
| 102 | 325 | ||
| 103 | //INT | 326 | //head=Call |
| 104 | public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } | 327 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } |
| 328 | |||
| 329 | //Call | ||
| 330 | public RuleCall getHeadCallParserRuleCall_1_0() { return cHeadCallParserRuleCall_1_0; } | ||
| 331 | |||
| 332 | //":" | ||
| 333 | public Keyword getColonKeyword_2() { return cColonKeyword_2; } | ||
| 334 | |||
| 335 | //range=Expression | ||
| 336 | public Assignment getRangeAssignment_3() { return cRangeAssignment_3; } | ||
| 337 | |||
| 338 | //Expression | ||
| 339 | public RuleCall getRangeExpressionParserRuleCall_3_0() { return cRangeExpressionParserRuleCall_3_0; } | ||
| 105 | } | 340 | } |
| 106 | public class BooleanValueElements extends AbstractParserRuleElementFinder { | 341 | public class ExternPredicateDefinitionElements extends AbstractParserRuleElementFinder { |
| 107 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); | 342 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternPredicateDefinition"); |
| 108 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 343 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 109 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); | 344 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 110 | private final Action cBooleanTrueAction_0_0 = (Action)cGroup_0.eContents().get(0); | 345 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 111 | private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); | 346 | private final RuleCall cHeadCallParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); |
| 112 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | ||
| 113 | private final Keyword cFalseKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); | ||
| 114 | private final Action cBooleanFalseAction_1_1 = (Action)cGroup_1.eContents().get(1); | ||
| 115 | 347 | ||
| 116 | //BooleanValue: | 348 | //ExternPredicateDefinition: |
| 117 | // {BooleanTrue} 'true' | 'false' {BooleanFalse}; | 349 | // "extern" head=Call; |
| 118 | @Override public ParserRule getRule() { return rule; } | 350 | @Override public ParserRule getRule() { return rule; } |
| 119 | 351 | ||
| 120 | //{BooleanTrue} 'true' | 'false' {BooleanFalse} | 352 | //"extern" head=Call |
| 121 | public Alternatives getAlternatives() { return cAlternatives; } | 353 | public Group getGroup() { return cGroup; } |
| 122 | 354 | ||
| 123 | //{BooleanTrue} 'true' | 355 | //"extern" |
| 124 | public Group getGroup_0() { return cGroup_0; } | 356 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } |
| 125 | 357 | ||
| 126 | //{BooleanTrue} | 358 | //head=Call |
| 127 | public Action getBooleanTrueAction_0_0() { return cBooleanTrueAction_0_0; } | 359 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } |
| 128 | 360 | ||
| 129 | //'true' | 361 | //Call |
| 130 | public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; } | 362 | public RuleCall getHeadCallParserRuleCall_1_0() { return cHeadCallParserRuleCall_1_0; } |
| 363 | } | ||
| 364 | public class MetricDefinitionElements extends AbstractParserRuleElementFinder { | ||
| 365 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MetricDefinition"); | ||
| 366 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 367 | private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
| 368 | private final RuleCall cTypeMetricTypeEnumRuleCall_0_0 = (RuleCall)cTypeAssignment_0.eContents().get(0); | ||
| 369 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 370 | private final RuleCall cHeadExpressionParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); | ||
| 371 | private final Keyword cEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 372 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 373 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
| 374 | |||
| 375 | //MetricDefinition: | ||
| 376 | // type=MetricType head=Expression "=" body=Expression; | ||
| 377 | @Override public ParserRule getRule() { return rule; } | ||
| 131 | 378 | ||
| 132 | //'false' {BooleanFalse} | 379 | //type=MetricType head=Expression "=" body=Expression |
| 133 | public Group getGroup_1() { return cGroup_1; } | 380 | public Group getGroup() { return cGroup; } |
| 381 | |||
| 382 | //type=MetricType | ||
| 383 | public Assignment getTypeAssignment_0() { return cTypeAssignment_0; } | ||
| 384 | |||
| 385 | //MetricType | ||
| 386 | public RuleCall getTypeMetricTypeEnumRuleCall_0_0() { return cTypeMetricTypeEnumRuleCall_0_0; } | ||
| 387 | |||
| 388 | //head=Expression | ||
| 389 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } | ||
| 390 | |||
| 391 | //Expression | ||
| 392 | public RuleCall getHeadExpressionParserRuleCall_1_0() { return cHeadExpressionParserRuleCall_1_0; } | ||
| 393 | |||
| 394 | //"=" | ||
| 395 | public Keyword getEqualsSignKeyword_2() { return cEqualsSignKeyword_2; } | ||
| 134 | 396 | ||
| 135 | //'false' | 397 | //body=Expression |
| 136 | public Keyword getFalseKeyword_1_0() { return cFalseKeyword_1_0; } | 398 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } |
| 137 | 399 | ||
| 138 | //{BooleanFalse} | 400 | //Expression |
| 139 | public Action getBooleanFalseAction_1_1() { return cBooleanFalseAction_1_1; } | 401 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } |
| 140 | } | 402 | } |
| 141 | public class TruthValueElements extends AbstractParserRuleElementFinder { | 403 | public class ExternMetricDefinitionElements extends AbstractParserRuleElementFinder { |
| 142 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); | 404 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternMetricDefinition"); |
| 405 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 406 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
| 407 | private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 408 | private final RuleCall cTypeMetricTypeEnumRuleCall_1_0 = (RuleCall)cTypeAssignment_1.eContents().get(0); | ||
| 409 | private final Assignment cHeadAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 410 | private final RuleCall cHeadCallParserRuleCall_2_0 = (RuleCall)cHeadAssignment_2.eContents().get(0); | ||
| 411 | |||
| 412 | //ExternMetricDefinition: | ||
| 413 | // "extern" type=MetricType head=Call; | ||
| 414 | @Override public ParserRule getRule() { return rule; } | ||
| 415 | |||
| 416 | //"extern" type=MetricType head=Call | ||
| 417 | public Group getGroup() { return cGroup; } | ||
| 418 | |||
| 419 | //"extern" | ||
| 420 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } | ||
| 421 | |||
| 422 | //type=MetricType | ||
| 423 | public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } | ||
| 424 | |||
| 425 | //MetricType | ||
| 426 | public RuleCall getTypeMetricTypeEnumRuleCall_1_0() { return cTypeMetricTypeEnumRuleCall_1_0; } | ||
| 427 | |||
| 428 | //head=Call | ||
| 429 | public Assignment getHeadAssignment_2() { return cHeadAssignment_2; } | ||
| 430 | |||
| 431 | //Call | ||
| 432 | public RuleCall getHeadCallParserRuleCall_2_0() { return cHeadCallParserRuleCall_2_0; } | ||
| 433 | } | ||
| 434 | public class ExpressionElements extends AbstractParserRuleElementFinder { | ||
| 435 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
| 143 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 436 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 144 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); | 437 | private final RuleCall cIfElseParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 145 | private final Action cTrueAction_0_0 = (Action)cGroup_0.eContents().get(0); | 438 | private final RuleCall cDisjunctiveExpressionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 146 | private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); | 439 | |
| 147 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | 440 | //Expression: |
| 148 | private final Action cFalseAction_1_0 = (Action)cGroup_1.eContents().get(0); | 441 | // IfElse | DisjunctiveExpression; |
| 149 | private final Keyword cFalseKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); | ||
| 150 | private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2); | ||
| 151 | private final Action cUnknownAction_2_0 = (Action)cGroup_2.eContents().get(0); | ||
| 152 | private final Keyword cUnknownKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1); | ||
| 153 | private final Group cGroup_3 = (Group)cAlternatives.eContents().get(3); | ||
| 154 | private final Action cErrorAction_3_0 = (Action)cGroup_3.eContents().get(0); | ||
| 155 | private final Keyword cErrorKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1); | ||
| 156 | |||
| 157 | //TruthValue: | ||
| 158 | // {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error'; | ||
| 159 | @Override public ParserRule getRule() { return rule; } | 442 | @Override public ParserRule getRule() { return rule; } |
| 160 | 443 | ||
| 161 | //{True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error' | 444 | //IfElse | DisjunctiveExpression |
| 162 | public Alternatives getAlternatives() { return cAlternatives; } | 445 | public Alternatives getAlternatives() { return cAlternatives; } |
| 163 | 446 | ||
| 164 | //{True} 'true' | 447 | //IfElse |
| 165 | public Group getGroup_0() { return cGroup_0; } | 448 | public RuleCall getIfElseParserRuleCall_0() { return cIfElseParserRuleCall_0; } |
| 166 | 449 | ||
| 167 | //{True} | 450 | //DisjunctiveExpression |
| 168 | public Action getTrueAction_0_0() { return cTrueAction_0_0; } | 451 | public RuleCall getDisjunctiveExpressionParserRuleCall_1() { return cDisjunctiveExpressionParserRuleCall_1; } |
| 452 | } | ||
| 453 | public class IfElseElements extends AbstractParserRuleElementFinder { | ||
| 454 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IfElse"); | ||
| 455 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 456 | private final Keyword cIfKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
| 457 | private final Assignment cConditionAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 458 | private final RuleCall cConditionExpressionParserRuleCall_1_0 = (RuleCall)cConditionAssignment_1.eContents().get(0); | ||
| 459 | private final Keyword cThenKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 460 | private final Assignment cThenAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 461 | private final RuleCall cThenExpressionParserRuleCall_3_0 = (RuleCall)cThenAssignment_3.eContents().get(0); | ||
| 462 | private final Keyword cElseKeyword_4 = (Keyword)cGroup.eContents().get(4); | ||
| 463 | private final Assignment cElseAssignment_5 = (Assignment)cGroup.eContents().get(5); | ||
| 464 | private final RuleCall cElseExpressionParserRuleCall_5_0 = (RuleCall)cElseAssignment_5.eContents().get(0); | ||
| 465 | |||
| 466 | //IfElse: | ||
| 467 | // "if" condition=Expression "then" then=Expression "else" else=Expression; | ||
| 468 | @Override public ParserRule getRule() { return rule; } | ||
| 169 | 469 | ||
| 170 | //'true' | 470 | //"if" condition=Expression "then" then=Expression "else" else=Expression |
| 171 | public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; } | 471 | public Group getGroup() { return cGroup; } |
| 172 | 472 | ||
| 173 | //{False} 'false' | 473 | //"if" |
| 174 | public Group getGroup_1() { return cGroup_1; } | 474 | public Keyword getIfKeyword_0() { return cIfKeyword_0; } |
| 175 | 475 | ||
| 176 | //{False} | 476 | //condition=Expression |
| 177 | public Action getFalseAction_1_0() { return cFalseAction_1_0; } | 477 | public Assignment getConditionAssignment_1() { return cConditionAssignment_1; } |
| 178 | 478 | ||
| 179 | //'false' | 479 | //Expression |
| 180 | public Keyword getFalseKeyword_1_1() { return cFalseKeyword_1_1; } | 480 | public RuleCall getConditionExpressionParserRuleCall_1_0() { return cConditionExpressionParserRuleCall_1_0; } |
| 181 | 481 | ||
| 182 | //{Unknown} 'unknown' | 482 | //"then" |
| 183 | public Group getGroup_2() { return cGroup_2; } | 483 | public Keyword getThenKeyword_2() { return cThenKeyword_2; } |
| 184 | 484 | ||
| 185 | //{Unknown} | 485 | //then=Expression |
| 186 | public Action getUnknownAction_2_0() { return cUnknownAction_2_0; } | 486 | public Assignment getThenAssignment_3() { return cThenAssignment_3; } |
| 187 | 487 | ||
| 188 | //'unknown' | 488 | //Expression |
| 189 | public Keyword getUnknownKeyword_2_1() { return cUnknownKeyword_2_1; } | 489 | public RuleCall getThenExpressionParserRuleCall_3_0() { return cThenExpressionParserRuleCall_3_0; } |
| 190 | 490 | ||
| 191 | //{Error} 'error' | 491 | //"else" |
| 192 | public Group getGroup_3() { return cGroup_3; } | 492 | public Keyword getElseKeyword_4() { return cElseKeyword_4; } |
| 193 | 493 | ||
| 194 | //{Error} | 494 | //else=Expression |
| 195 | public Action getErrorAction_3_0() { return cErrorAction_3_0; } | 495 | public Assignment getElseAssignment_5() { return cElseAssignment_5; } |
| 196 | 496 | ||
| 197 | //'error' | 497 | //Expression |
| 198 | public Keyword getErrorKeyword_3_1() { return cErrorKeyword_3_1; } | 498 | public RuleCall getElseExpressionParserRuleCall_5_0() { return cElseExpressionParserRuleCall_5_0; } |
| 199 | } | 499 | } |
| 200 | public class InterpretationElements extends AbstractParserRuleElementFinder { | 500 | public class DisjunctiveExpressionElements extends AbstractParserRuleElementFinder { |
| 201 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Interpretation"); | 501 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); |
| 202 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 502 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 203 | private final RuleCall cBasicInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 503 | private final RuleCall cConjunctiveExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); |
| 204 | private final RuleCall cDefaultInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 504 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); |
| 205 | private final RuleCall cCDInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 505 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); |
| 206 | 506 | private final Action cDisjunctionChildrenAction_1_0_0 = (Action)cGroup_1_0.eContents().get(0); | |
| 207 | ///////////////////// | 507 | private final Group cGroup_1_0_1 = (Group)cGroup_1_0.eContents().get(1); |
| 208 | //// Core grammar | 508 | private final Keyword cSemicolonKeyword_1_0_1_0 = (Keyword)cGroup_1_0_1.eContents().get(0); |
| 209 | // /////////////////// | 509 | private final Assignment cChildrenAssignment_1_0_1_1 = (Assignment)cGroup_1_0_1.eContents().get(1); |
| 210 | //Interpretation: | 510 | private final RuleCall cChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0 = (RuleCall)cChildrenAssignment_1_0_1_1.eContents().get(0); |
| 211 | // BasicInterpretation | DefaultInterpretation | CDInterpretation; | 511 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); |
| 512 | private final Action cCaseConditionAction_1_1_0 = (Action)cGroup_1_1.eContents().get(0); | ||
| 513 | private final Keyword cHyphenMinusGreaterThanSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
| 514 | private final Assignment cBodyAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
| 515 | private final RuleCall cBodyConjunctiveExpressionParserRuleCall_1_1_2_0 = (RuleCall)cBodyAssignment_1_1_2.eContents().get(0); | ||
| 516 | private final Action cSwitchCasesAction_1_1_3 = (Action)cGroup_1_1.eContents().get(3); | ||
| 517 | private final Group cGroup_1_1_4 = (Group)cGroup_1_1.eContents().get(4); | ||
| 518 | private final Keyword cSemicolonKeyword_1_1_4_0 = (Keyword)cGroup_1_1_4.eContents().get(0); | ||
| 519 | private final Assignment cCasesAssignment_1_1_4_1 = (Assignment)cGroup_1_1_4.eContents().get(1); | ||
| 520 | private final RuleCall cCasesCaseParserRuleCall_1_1_4_1_0 = (RuleCall)cCasesAssignment_1_1_4_1.eContents().get(0); | ||
| 521 | |||
| 522 | //DisjunctiveExpression Expression: | ||
| 523 | // ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | | ||
| 524 | // {Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)?; | ||
| 212 | @Override public ParserRule getRule() { return rule; } | 525 | @Override public ParserRule getRule() { return rule; } |
| 213 | 526 | ||
| 214 | //BasicInterpretation | DefaultInterpretation | CDInterpretation | 527 | //ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | {Case.condition=current} |
| 215 | public Alternatives getAlternatives() { return cAlternatives; } | 528 | //"->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)? |
| 529 | public Group getGroup() { return cGroup; } | ||
| 216 | 530 | ||
| 217 | //BasicInterpretation | 531 | //ConjunctiveExpression |
| 218 | public RuleCall getBasicInterpretationParserRuleCall_0() { return cBasicInterpretationParserRuleCall_0; } | 532 | public RuleCall getConjunctiveExpressionParserRuleCall_0() { return cConjunctiveExpressionParserRuleCall_0; } |
| 533 | |||
| 534 | //({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | {Case.condition=current} "->" | ||
| 535 | //body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)? | ||
| 536 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
| 537 | |||
| 538 | //{Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | ||
| 539 | public Group getGroup_1_0() { return cGroup_1_0; } | ||
| 540 | |||
| 541 | //{Disjunction.children+=current} | ||
| 542 | public Action getDisjunctionChildrenAction_1_0_0() { return cDisjunctionChildrenAction_1_0_0; } | ||
| 543 | |||
| 544 | //(";" children+=ConjunctiveExpression)+ | ||
| 545 | public Group getGroup_1_0_1() { return cGroup_1_0_1; } | ||
| 546 | |||
| 547 | //";" | ||
| 548 | public Keyword getSemicolonKeyword_1_0_1_0() { return cSemicolonKeyword_1_0_1_0; } | ||
| 549 | |||
| 550 | //children+=ConjunctiveExpression | ||
| 551 | public Assignment getChildrenAssignment_1_0_1_1() { return cChildrenAssignment_1_0_1_1; } | ||
| 552 | |||
| 553 | //ConjunctiveExpression | ||
| 554 | public RuleCall getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0() { return cChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0; } | ||
| 555 | |||
| 556 | //{Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)* | ||
| 557 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
| 219 | 558 | ||
| 220 | //DefaultInterpretation | 559 | //{Case.condition=current} |
| 221 | public RuleCall getDefaultInterpretationParserRuleCall_1() { return cDefaultInterpretationParserRuleCall_1; } | 560 | public Action getCaseConditionAction_1_1_0() { return cCaseConditionAction_1_1_0; } |
| 222 | 561 | ||
| 223 | //CDInterpretation | 562 | //"->" |
| 224 | public RuleCall getCDInterpretationParserRuleCall_2() { return cCDInterpretationParserRuleCall_2; } | 563 | public Keyword getHyphenMinusGreaterThanSignKeyword_1_1_1() { return cHyphenMinusGreaterThanSignKeyword_1_1_1; } |
| 564 | |||
| 565 | //body=ConjunctiveExpression | ||
| 566 | public Assignment getBodyAssignment_1_1_2() { return cBodyAssignment_1_1_2; } | ||
| 567 | |||
| 568 | //ConjunctiveExpression | ||
| 569 | public RuleCall getBodyConjunctiveExpressionParserRuleCall_1_1_2_0() { return cBodyConjunctiveExpressionParserRuleCall_1_1_2_0; } | ||
| 570 | |||
| 571 | //{Switch.cases+=current} | ||
| 572 | public Action getSwitchCasesAction_1_1_3() { return cSwitchCasesAction_1_1_3; } | ||
| 573 | |||
| 574 | //(";" cases+=Case)* | ||
| 575 | public Group getGroup_1_1_4() { return cGroup_1_1_4; } | ||
| 576 | |||
| 577 | //";" | ||
| 578 | public Keyword getSemicolonKeyword_1_1_4_0() { return cSemicolonKeyword_1_1_4_0; } | ||
| 579 | |||
| 580 | //cases+=Case | ||
| 581 | public Assignment getCasesAssignment_1_1_4_1() { return cCasesAssignment_1_1_4_1; } | ||
| 582 | |||
| 583 | //Case | ||
| 584 | public RuleCall getCasesCaseParserRuleCall_1_1_4_1_0() { return cCasesCaseParserRuleCall_1_1_4_1_0; } | ||
| 225 | } | 585 | } |
| 226 | public class BasicInterpretationElements extends AbstractParserRuleElementFinder { | 586 | public class CaseElements extends AbstractParserRuleElementFinder { |
| 227 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); | 587 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Case"); |
| 228 | private final Group cGroup = (Group)rule.eContents().get(1); | 588 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 229 | private final Assignment cSymbolAssignment_0 = (Assignment)cGroup.eContents().get(0); | 589 | private final Assignment cConditionAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 230 | private final RuleCall cSymbolSymbolParserRuleCall_0_0 = (RuleCall)cSymbolAssignment_0.eContents().get(0); | 590 | private final RuleCall cConditionConjunctiveExpressionParserRuleCall_0_0 = (RuleCall)cConditionAssignment_0.eContents().get(0); |
| 591 | private final Keyword cHyphenMinusGreaterThanSignKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 592 | private final Assignment cBodyAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 593 | private final RuleCall cBodyConjunctiveExpressionParserRuleCall_2_0 = (RuleCall)cBodyAssignment_2.eContents().get(0); | ||
| 594 | |||
| 595 | //Case: | ||
| 596 | // condition=ConjunctiveExpression "->" body=ConjunctiveExpression; | ||
| 597 | @Override public ParserRule getRule() { return rule; } | ||
| 598 | |||
| 599 | //condition=ConjunctiveExpression "->" body=ConjunctiveExpression | ||
| 600 | public Group getGroup() { return cGroup; } | ||
| 601 | |||
| 602 | //condition=ConjunctiveExpression | ||
| 603 | public Assignment getConditionAssignment_0() { return cConditionAssignment_0; } | ||
| 604 | |||
| 605 | //ConjunctiveExpression | ||
| 606 | public RuleCall getConditionConjunctiveExpressionParserRuleCall_0_0() { return cConditionConjunctiveExpressionParserRuleCall_0_0; } | ||
| 607 | |||
| 608 | //"->" | ||
| 609 | public Keyword getHyphenMinusGreaterThanSignKeyword_1() { return cHyphenMinusGreaterThanSignKeyword_1; } | ||
| 610 | |||
| 611 | //body=ConjunctiveExpression | ||
| 612 | public Assignment getBodyAssignment_2() { return cBodyAssignment_2; } | ||
| 613 | |||
| 614 | //ConjunctiveExpression | ||
| 615 | public RuleCall getBodyConjunctiveExpressionParserRuleCall_2_0() { return cBodyConjunctiveExpressionParserRuleCall_2_0; } | ||
| 616 | } | ||
| 617 | public class ConjunctiveExpressionElements extends AbstractParserRuleElementFinder { | ||
| 618 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
| 619 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 620 | private final RuleCall cComparisonExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
| 231 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | 621 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); |
| 232 | private final Keyword cLeftParenthesisKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); | 622 | private final Action cConjunctionChildrenAction_1_0 = (Action)cGroup_1.eContents().get(0); |
| 233 | private final Group cGroup_1_1 = (Group)cGroup_1.eContents().get(1); | 623 | private final Group cGroup_1_1 = (Group)cGroup_1.eContents().get(1); |
| 234 | private final Assignment cObjectsAssignment_1_1_0 = (Assignment)cGroup_1_1.eContents().get(0); | 624 | private final Keyword cCommaKeyword_1_1_0 = (Keyword)cGroup_1_1.eContents().get(0); |
| 235 | private final RuleCall cObjectsComplexObjectParserRuleCall_1_1_0_0 = (RuleCall)cObjectsAssignment_1_1_0.eContents().get(0); | 625 | private final Assignment cChildrenAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1); |
| 236 | private final Group cGroup_1_1_1 = (Group)cGroup_1_1.eContents().get(1); | 626 | private final RuleCall cChildrenComparisonExpressionParserRuleCall_1_1_1_0 = (RuleCall)cChildrenAssignment_1_1_1.eContents().get(0); |
| 237 | private final Keyword cCommaKeyword_1_1_1_0 = (Keyword)cGroup_1_1_1.eContents().get(0); | ||
| 238 | private final Assignment cObjectsAssignment_1_1_1_1 = (Assignment)cGroup_1_1_1.eContents().get(1); | ||
| 239 | private final RuleCall cObjectsComplexObjectParserRuleCall_1_1_1_1_0 = (RuleCall)cObjectsAssignment_1_1_1_1.eContents().get(0); | ||
| 240 | private final Keyword cRightParenthesisKeyword_1_2 = (Keyword)cGroup_1.eContents().get(2); | ||
| 241 | private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 242 | private final Assignment cValueAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 243 | private final RuleCall cValueTruthValueParserRuleCall_3_0 = (RuleCall)cValueAssignment_3.eContents().get(0); | ||
| 244 | 627 | ||
| 245 | //BasicInterpretation: | 628 | //ConjunctiveExpression Expression: |
| 246 | // symbol=Symbol ('(' (objects+=ComplexObject (',' objects+=ComplexObject)*)? ')')? ':' value=TruthValue; | 629 | // ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)?; |
| 247 | @Override public ParserRule getRule() { return rule; } | 630 | @Override public ParserRule getRule() { return rule; } |
| 248 | 631 | ||
| 249 | //symbol=Symbol ('(' (objects+=ComplexObject (',' objects+=ComplexObject)*)? ')')? ':' value=TruthValue | 632 | //ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)? |
| 250 | public Group getGroup() { return cGroup; } | 633 | public Group getGroup() { return cGroup; } |
| 251 | 634 | ||
| 252 | //symbol=Symbol | 635 | //ComparisonExpression |
| 253 | public Assignment getSymbolAssignment_0() { return cSymbolAssignment_0; } | 636 | public RuleCall getComparisonExpressionParserRuleCall_0() { return cComparisonExpressionParserRuleCall_0; } |
| 254 | |||
| 255 | //Symbol | ||
| 256 | public RuleCall getSymbolSymbolParserRuleCall_0_0() { return cSymbolSymbolParserRuleCall_0_0; } | ||
| 257 | 637 | ||
| 258 | //('(' (objects+=ComplexObject (',' objects+=ComplexObject)*)? ')')? | 638 | //({Conjunction.children+=current} ("," children+=ComparisonExpression)+)? |
| 259 | public Group getGroup_1() { return cGroup_1; } | 639 | public Group getGroup_1() { return cGroup_1; } |
| 260 | 640 | ||
| 261 | //'(' | 641 | //{Conjunction.children+=current} |
| 262 | public Keyword getLeftParenthesisKeyword_1_0() { return cLeftParenthesisKeyword_1_0; } | 642 | public Action getConjunctionChildrenAction_1_0() { return cConjunctionChildrenAction_1_0; } |
| 263 | 643 | ||
| 264 | //(objects+=ComplexObject (',' objects+=ComplexObject)*)? | 644 | //("," children+=ComparisonExpression)+ |
| 265 | public Group getGroup_1_1() { return cGroup_1_1; } | 645 | public Group getGroup_1_1() { return cGroup_1_1; } |
| 266 | 646 | ||
| 267 | //objects+=ComplexObject | 647 | //"," |
| 268 | public Assignment getObjectsAssignment_1_1_0() { return cObjectsAssignment_1_1_0; } | 648 | public Keyword getCommaKeyword_1_1_0() { return cCommaKeyword_1_1_0; } |
| 269 | 649 | ||
| 270 | //ComplexObject | 650 | //children+=ComparisonExpression |
| 271 | public RuleCall getObjectsComplexObjectParserRuleCall_1_1_0_0() { return cObjectsComplexObjectParserRuleCall_1_1_0_0; } | 651 | public Assignment getChildrenAssignment_1_1_1() { return cChildrenAssignment_1_1_1; } |
| 272 | 652 | ||
| 273 | //(',' objects+=ComplexObject)* | 653 | //ComparisonExpression |
| 274 | public Group getGroup_1_1_1() { return cGroup_1_1_1; } | 654 | public RuleCall getChildrenComparisonExpressionParserRuleCall_1_1_1_0() { return cChildrenComparisonExpressionParserRuleCall_1_1_1_0; } |
| 655 | } | ||
| 656 | public class ComparisonExpressionElements extends AbstractParserRuleElementFinder { | ||
| 657 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
| 658 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 659 | private final RuleCall cAdditiveExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
| 660 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
| 661 | private final Action cComparisonLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
| 662 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 663 | private final RuleCall cOpComparisonOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
| 664 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
| 665 | private final RuleCall cRightAdditiveExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
| 666 | |||
| 667 | //ComparisonExpression Expression: | ||
| 668 | // AdditiveExpression ({Comparison.left=current} op=ComparisonOperator right=AdditiveExpression)?; | ||
| 669 | @Override public ParserRule getRule() { return rule; } | ||
| 275 | 670 | ||
| 276 | //',' | 671 | //AdditiveExpression ({Comparison.left=current} op=ComparisonOperator right=AdditiveExpression)? |
| 277 | public Keyword getCommaKeyword_1_1_1_0() { return cCommaKeyword_1_1_1_0; } | 672 | public Group getGroup() { return cGroup; } |
| 278 | 673 | ||
| 279 | //objects+=ComplexObject | 674 | //AdditiveExpression |
| 280 | public Assignment getObjectsAssignment_1_1_1_1() { return cObjectsAssignment_1_1_1_1; } | 675 | public RuleCall getAdditiveExpressionParserRuleCall_0() { return cAdditiveExpressionParserRuleCall_0; } |
| 281 | 676 | ||
| 282 | //ComplexObject | 677 | //({Comparison.left=current} op=ComparisonOperator right=AdditiveExpression)? |
| 283 | public RuleCall getObjectsComplexObjectParserRuleCall_1_1_1_1_0() { return cObjectsComplexObjectParserRuleCall_1_1_1_1_0; } | 678 | public Group getGroup_1() { return cGroup_1; } |
| 284 | 679 | ||
| 285 | //')' | 680 | //{Comparison.left=current} |
| 286 | public Keyword getRightParenthesisKeyword_1_2() { return cRightParenthesisKeyword_1_2; } | 681 | public Action getComparisonLeftAction_1_0() { return cComparisonLeftAction_1_0; } |
| 287 | 682 | ||
| 288 | //':' | 683 | //op=ComparisonOperator |
| 289 | public Keyword getColonKeyword_2() { return cColonKeyword_2; } | 684 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } |
| 290 | 685 | ||
| 291 | //value=TruthValue | 686 | //ComparisonOperator |
| 292 | public Assignment getValueAssignment_3() { return cValueAssignment_3; } | 687 | public RuleCall getOpComparisonOperatorEnumRuleCall_1_1_0() { return cOpComparisonOperatorEnumRuleCall_1_1_0; } |
| 293 | 688 | ||
| 294 | //TruthValue | 689 | //right=AdditiveExpression |
| 295 | public RuleCall getValueTruthValueParserRuleCall_3_0() { return cValueTruthValueParserRuleCall_3_0; } | 690 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } |
| 691 | |||
| 692 | //AdditiveExpression | ||
| 693 | public RuleCall getRightAdditiveExpressionParserRuleCall_1_2_0() { return cRightAdditiveExpressionParserRuleCall_1_2_0; } | ||
| 296 | } | 694 | } |
| 297 | public class SymbolElements extends AbstractParserRuleElementFinder { | 695 | public class AdditiveExpressionElements extends AbstractParserRuleElementFinder { |
| 298 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); | 696 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); |
| 299 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 697 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 300 | private final RuleCall cModelSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 698 | private final RuleCall cMultiplicativeExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); |
| 301 | private final RuleCall cPartialitySymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 699 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); |
| 302 | private final RuleCall cDataSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 700 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); |
| 701 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 702 | private final RuleCall cOpAdditiveBinaryOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
| 703 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
| 704 | private final RuleCall cRightMultiplicativeExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
| 705 | |||
| 706 | //AdditiveExpression Expression: | ||
| 707 | // MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)*; | ||
| 708 | @Override public ParserRule getRule() { return rule; } | ||
| 303 | 709 | ||
| 304 | //Symbol: | 710 | //MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)* |
| 305 | // ModelSymbol | PartialitySymbol | DataSymbol; | 711 | public Group getGroup() { return cGroup; } |
| 712 | |||
| 713 | //MultiplicativeExpression | ||
| 714 | public RuleCall getMultiplicativeExpressionParserRuleCall_0() { return cMultiplicativeExpressionParserRuleCall_0; } | ||
| 715 | |||
| 716 | //({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)* | ||
| 717 | public Group getGroup_1() { return cGroup_1; } | ||
| 718 | |||
| 719 | //{BinaryExpression.left=current} | ||
| 720 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
| 721 | |||
| 722 | //op=AdditiveBinaryOperator | ||
| 723 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
| 724 | |||
| 725 | //AdditiveBinaryOperator | ||
| 726 | public RuleCall getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0() { return cOpAdditiveBinaryOperatorEnumRuleCall_1_1_0; } | ||
| 727 | |||
| 728 | //right=MultiplicativeExpression | ||
| 729 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
| 730 | |||
| 731 | //MultiplicativeExpression | ||
| 732 | public RuleCall getRightMultiplicativeExpressionParserRuleCall_1_2_0() { return cRightMultiplicativeExpressionParserRuleCall_1_2_0; } | ||
| 733 | } | ||
| 734 | public class MultiplicativeExpressionElements extends AbstractParserRuleElementFinder { | ||
| 735 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
| 736 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 737 | private final RuleCall cExponentialExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
| 738 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
| 739 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
| 740 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 741 | private final RuleCall cOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
| 742 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
| 743 | private final RuleCall cRightExponentialExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
| 744 | |||
| 745 | //MultiplicativeExpression Expression: | ||
| 746 | // ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)*; | ||
| 306 | @Override public ParserRule getRule() { return rule; } | 747 | @Override public ParserRule getRule() { return rule; } |
| 307 | 748 | ||
| 308 | //ModelSymbol | PartialitySymbol | DataSymbol | 749 | //ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)* |
| 309 | public Alternatives getAlternatives() { return cAlternatives; } | 750 | public Group getGroup() { return cGroup; } |
| 751 | |||
| 752 | //ExponentialExpression | ||
| 753 | public RuleCall getExponentialExpressionParserRuleCall_0() { return cExponentialExpressionParserRuleCall_0; } | ||
| 310 | 754 | ||
| 311 | //ModelSymbol | 755 | //({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)* |
| 312 | public RuleCall getModelSymbolParserRuleCall_0() { return cModelSymbolParserRuleCall_0; } | 756 | public Group getGroup_1() { return cGroup_1; } |
| 313 | 757 | ||
| 314 | //PartialitySymbol | 758 | //{BinaryExpression.left=current} |
| 315 | public RuleCall getPartialitySymbolParserRuleCall_1() { return cPartialitySymbolParserRuleCall_1; } | 759 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } |
| 316 | 760 | ||
| 317 | //DataSymbol | 761 | //op=MultiplicativeBinaryOperator |
| 318 | public RuleCall getDataSymbolParserRuleCall_2() { return cDataSymbolParserRuleCall_2; } | 762 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } |
| 763 | |||
| 764 | //MultiplicativeBinaryOperator | ||
| 765 | public RuleCall getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0() { return cOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0; } | ||
| 766 | |||
| 767 | //right=ExponentialExpression | ||
| 768 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
| 769 | |||
| 770 | //ExponentialExpression | ||
| 771 | public RuleCall getRightExponentialExpressionParserRuleCall_1_2_0() { return cRightExponentialExpressionParserRuleCall_1_2_0; } | ||
| 319 | } | 772 | } |
| 320 | public class ModelSymbolElements extends AbstractParserRuleElementFinder { | 773 | public class ExponentialExpressionElements extends AbstractParserRuleElementFinder { |
| 321 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); | 774 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); |
| 322 | private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); | 775 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 323 | private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); | 776 | private final RuleCall cUnaryExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); |
| 777 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
| 778 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
| 779 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 780 | private final RuleCall cOpExponentialOpEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
| 781 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
| 782 | private final RuleCall cRightExponentialExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
| 783 | |||
| 784 | //ExponentialExpression Expression: | ||
| 785 | // UnaryExpression ({BinaryExpression.left=current} op=ExponentialOp right=ExponentialExpression)?; | ||
| 786 | @Override public ParserRule getRule() { return rule; } | ||
| 787 | |||
| 788 | //UnaryExpression ({BinaryExpression.left=current} op=ExponentialOp right=ExponentialExpression)? | ||
| 789 | public Group getGroup() { return cGroup; } | ||
| 790 | |||
| 791 | //UnaryExpression | ||
| 792 | public RuleCall getUnaryExpressionParserRuleCall_0() { return cUnaryExpressionParserRuleCall_0; } | ||
| 793 | |||
| 794 | //({BinaryExpression.left=current} op=ExponentialOp right=ExponentialExpression)? | ||
| 795 | public Group getGroup_1() { return cGroup_1; } | ||
| 796 | |||
| 797 | //{BinaryExpression.left=current} | ||
| 798 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
| 799 | |||
| 800 | //op=ExponentialOp | ||
| 801 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
| 802 | |||
| 803 | //ExponentialOp | ||
| 804 | public RuleCall getOpExponentialOpEnumRuleCall_1_1_0() { return cOpExponentialOpEnumRuleCall_1_1_0; } | ||
| 324 | 805 | ||
| 325 | //ModelSymbol: | 806 | //right=ExponentialExpression |
| 326 | // name=ID; | 807 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } |
| 808 | |||
| 809 | //ExponentialExpression | ||
| 810 | public RuleCall getRightExponentialExpressionParserRuleCall_1_2_0() { return cRightExponentialExpressionParserRuleCall_1_2_0; } | ||
| 811 | } | ||
| 812 | public class UnaryExpressionElements extends AbstractParserRuleElementFinder { | ||
| 813 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnaryExpression"); | ||
| 814 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 815 | private final RuleCall cAggregationExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
| 816 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | ||
| 817 | private final Action cUnaryExpressionAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
| 818 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 819 | private final RuleCall cOpUnaryOpEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
| 820 | private final Assignment cBodyAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
| 821 | private final RuleCall cBodyAggregationExpressionParserRuleCall_1_2_0 = (RuleCall)cBodyAssignment_1_2.eContents().get(0); | ||
| 822 | |||
| 823 | //UnaryExpression Expression: | ||
| 824 | // AggregationExpression | {UnaryExpression} op=UnaryOp body=AggregationExpression; | ||
| 327 | @Override public ParserRule getRule() { return rule; } | 825 | @Override public ParserRule getRule() { return rule; } |
| 328 | 826 | ||
| 329 | //name=ID | 827 | //AggregationExpression | {UnaryExpression} op=UnaryOp body=AggregationExpression |
| 330 | public Assignment getNameAssignment() { return cNameAssignment; } | 828 | public Alternatives getAlternatives() { return cAlternatives; } |
| 331 | 829 | ||
| 332 | //ID | 830 | //AggregationExpression |
| 333 | public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } | 831 | public RuleCall getAggregationExpressionParserRuleCall_0() { return cAggregationExpressionParserRuleCall_0; } |
| 832 | |||
| 833 | //{UnaryExpression} op=UnaryOp body=AggregationExpression | ||
| 834 | public Group getGroup_1() { return cGroup_1; } | ||
| 835 | |||
| 836 | //{UnaryExpression} | ||
| 837 | public Action getUnaryExpressionAction_1_0() { return cUnaryExpressionAction_1_0; } | ||
| 838 | |||
| 839 | //op=UnaryOp | ||
| 840 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
| 841 | |||
| 842 | //UnaryOp | ||
| 843 | public RuleCall getOpUnaryOpEnumRuleCall_1_1_0() { return cOpUnaryOpEnumRuleCall_1_1_0; } | ||
| 844 | |||
| 845 | //body=AggregationExpression | ||
| 846 | public Assignment getBodyAssignment_1_2() { return cBodyAssignment_1_2; } | ||
| 847 | |||
| 848 | //AggregationExpression | ||
| 849 | public RuleCall getBodyAggregationExpressionParserRuleCall_1_2_0() { return cBodyAggregationExpressionParserRuleCall_1_2_0; } | ||
| 334 | } | 850 | } |
| 335 | public class PartialitySymbolElements extends AbstractParserRuleElementFinder { | 851 | public class AggregationExpressionElements extends AbstractParserRuleElementFinder { |
| 336 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PartialitySymbol"); | 852 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); |
| 337 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 853 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 338 | private final RuleCall cExistSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 854 | private final RuleCall cAtomicExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 339 | private final RuleCall cEqualsSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 855 | private final RuleCall cCountParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 856 | private final RuleCall cAggregationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
| 340 | 857 | ||
| 341 | //PartialitySymbol: | 858 | //AggregationExpression Expression: |
| 342 | // ExistSymbol | EqualsSymbol; | 859 | // AtomicExpression | Count | Aggregation; |
| 343 | @Override public ParserRule getRule() { return rule; } | 860 | @Override public ParserRule getRule() { return rule; } |
| 344 | 861 | ||
| 345 | //ExistSymbol | EqualsSymbol | 862 | //AtomicExpression | Count | Aggregation |
| 346 | public Alternatives getAlternatives() { return cAlternatives; } | 863 | public Alternatives getAlternatives() { return cAlternatives; } |
| 347 | 864 | ||
| 348 | //ExistSymbol | 865 | //AtomicExpression |
| 349 | public RuleCall getExistSymbolParserRuleCall_0() { return cExistSymbolParserRuleCall_0; } | 866 | public RuleCall getAtomicExpressionParserRuleCall_0() { return cAtomicExpressionParserRuleCall_0; } |
| 867 | |||
| 868 | //Count | ||
| 869 | public RuleCall getCountParserRuleCall_1() { return cCountParserRuleCall_1; } | ||
| 350 | 870 | ||
| 351 | //EqualsSymbol | 871 | //Aggregation |
| 352 | public RuleCall getEqualsSymbolParserRuleCall_1() { return cEqualsSymbolParserRuleCall_1; } | 872 | public RuleCall getAggregationParserRuleCall_2() { return cAggregationParserRuleCall_2; } |
| 353 | } | 873 | } |
| 354 | public class ExistSymbolElements extends AbstractParserRuleElementFinder { | 874 | public class CountElements extends AbstractParserRuleElementFinder { |
| 355 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExistSymbol"); | 875 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Count"); |
| 356 | private final Group cGroup = (Group)rule.eContents().get(1); | 876 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 357 | private final Keyword cExistsKeyword_0 = (Keyword)cGroup.eContents().get(0); | 877 | private final Keyword cCountKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 358 | private final Action cExistSymbolAction_1 = (Action)cGroup.eContents().get(1); | 878 | private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| 359 | 879 | private final Assignment cBodyAssignment_2 = (Assignment)cGroup.eContents().get(2); | |
| 360 | //ExistSymbol: | 880 | private final RuleCall cBodyExpressionParserRuleCall_2_0 = (RuleCall)cBodyAssignment_2.eContents().get(0); |
| 361 | // 'exists' {ExistSymbol}; | 881 | private final Keyword cRightCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); |
| 882 | |||
| 883 | //Count: | ||
| 884 | // "count" "{" body=Expression "}"; | ||
| 362 | @Override public ParserRule getRule() { return rule; } | 885 | @Override public ParserRule getRule() { return rule; } |
| 363 | 886 | ||
| 364 | //'exists' {ExistSymbol} | 887 | //"count" "{" body=Expression "}" |
| 365 | public Group getGroup() { return cGroup; } | 888 | public Group getGroup() { return cGroup; } |
| 366 | 889 | ||
| 367 | //'exists' | 890 | //"count" |
| 368 | public Keyword getExistsKeyword_0() { return cExistsKeyword_0; } | 891 | public Keyword getCountKeyword_0() { return cCountKeyword_0; } |
| 892 | |||
| 893 | //"{" | ||
| 894 | public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } | ||
| 895 | |||
| 896 | //body=Expression | ||
| 897 | public Assignment getBodyAssignment_2() { return cBodyAssignment_2; } | ||
| 369 | 898 | ||
| 370 | //{ExistSymbol} | 899 | //Expression |
| 371 | public Action getExistSymbolAction_1() { return cExistSymbolAction_1; } | 900 | public RuleCall getBodyExpressionParserRuleCall_2_0() { return cBodyExpressionParserRuleCall_2_0; } |
| 901 | |||
| 902 | //"}" | ||
| 903 | public Keyword getRightCurlyBracketKeyword_3() { return cRightCurlyBracketKeyword_3; } | ||
| 372 | } | 904 | } |
| 373 | public class EqualsSymbolElements extends AbstractParserRuleElementFinder { | 905 | public class AggregationElements extends AbstractParserRuleElementFinder { |
| 374 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EqualsSymbol"); | 906 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Aggregation"); |
| 375 | private final Group cGroup = (Group)rule.eContents().get(1); | 907 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 376 | private final Keyword cEqualsKeyword_0 = (Keyword)cGroup.eContents().get(0); | 908 | private final Assignment cOpAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 377 | private final Action cEqualsSymbolAction_1 = (Action)cGroup.eContents().get(1); | 909 | private final RuleCall cOpAggregationOpEnumRuleCall_0_0 = (RuleCall)cOpAssignment_0.eContents().get(0); |
| 378 | 910 | private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); | |
| 379 | //EqualsSymbol: | 911 | private final Assignment cBodyAssignment_2 = (Assignment)cGroup.eContents().get(2); |
| 380 | // 'equals' {EqualsSymbol}; | 912 | private final RuleCall cBodyExpressionParserRuleCall_2_0 = (RuleCall)cBodyAssignment_2.eContents().get(0); |
| 913 | private final Keyword cVerticalLineKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
| 914 | private final Assignment cConditionAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
| 915 | private final RuleCall cConditionExpressionParserRuleCall_4_0 = (RuleCall)cConditionAssignment_4.eContents().get(0); | ||
| 916 | private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
| 917 | |||
| 918 | //Aggregation: | ||
| 919 | // op=AggregationOp "{" body=Expression "|" condition=Expression "}"; | ||
| 381 | @Override public ParserRule getRule() { return rule; } | 920 | @Override public ParserRule getRule() { return rule; } |
| 382 | 921 | ||
| 383 | //'equals' {EqualsSymbol} | 922 | //op=AggregationOp "{" body=Expression "|" condition=Expression "}" |
| 384 | public Group getGroup() { return cGroup; } | 923 | public Group getGroup() { return cGroup; } |
| 385 | 924 | ||
| 386 | //'equals' | 925 | //op=AggregationOp |
| 387 | public Keyword getEqualsKeyword_0() { return cEqualsKeyword_0; } | 926 | public Assignment getOpAssignment_0() { return cOpAssignment_0; } |
| 388 | 927 | ||
| 389 | //{EqualsSymbol} | 928 | //AggregationOp |
| 390 | public Action getEqualsSymbolAction_1() { return cEqualsSymbolAction_1; } | 929 | public RuleCall getOpAggregationOpEnumRuleCall_0_0() { return cOpAggregationOpEnumRuleCall_0_0; } |
| 930 | |||
| 931 | //"{" | ||
| 932 | public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } | ||
| 933 | |||
| 934 | //body=Expression | ||
| 935 | public Assignment getBodyAssignment_2() { return cBodyAssignment_2; } | ||
| 936 | |||
| 937 | //Expression | ||
| 938 | public RuleCall getBodyExpressionParserRuleCall_2_0() { return cBodyExpressionParserRuleCall_2_0; } | ||
| 939 | |||
| 940 | //"|" | ||
| 941 | public Keyword getVerticalLineKeyword_3() { return cVerticalLineKeyword_3; } | ||
| 942 | |||
| 943 | //condition=Expression | ||
| 944 | public Assignment getConditionAssignment_4() { return cConditionAssignment_4; } | ||
| 945 | |||
| 946 | //Expression | ||
| 947 | public RuleCall getConditionExpressionParserRuleCall_4_0() { return cConditionExpressionParserRuleCall_4_0; } | ||
| 948 | |||
| 949 | //"}" | ||
| 950 | public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } | ||
| 391 | } | 951 | } |
| 392 | public class DataSymbolElements extends AbstractParserRuleElementFinder { | 952 | public class AtomicExpressionElements extends AbstractParserRuleElementFinder { |
| 393 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataSymbol"); | 953 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AtomicExpression"); |
| 394 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 954 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 395 | private final RuleCall cBooleanSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 955 | private final RuleCall cReferenceParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 396 | private final RuleCall cIntegerSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 956 | private final RuleCall cCallParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 397 | private final RuleCall cRealSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 957 | private final RuleCall cIntervalParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); |
| 398 | private final RuleCall cStringSymbolParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | 958 | private final RuleCall cLiteralParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); |
| 399 | 959 | private final Group cGroup_4 = (Group)cAlternatives.eContents().get(4); | |
| 400 | //DataSymbol: | 960 | private final Keyword cLeftParenthesisKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); |
| 401 | // BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol; | 961 | private final RuleCall cExpressionParserRuleCall_4_1 = (RuleCall)cGroup_4.eContents().get(1); |
| 962 | private final Keyword cRightParenthesisKeyword_4_2 = (Keyword)cGroup_4.eContents().get(2); | ||
| 963 | |||
| 964 | //AtomicExpression Expression: | ||
| 965 | // Reference | Call | Interval | Literal | "(" Expression ")"; | ||
| 402 | @Override public ParserRule getRule() { return rule; } | 966 | @Override public ParserRule getRule() { return rule; } |
| 403 | 967 | ||
| 404 | //BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol | 968 | //Reference | Call | Interval | Literal | "(" Expression ")" |
| 405 | public Alternatives getAlternatives() { return cAlternatives; } | 969 | public Alternatives getAlternatives() { return cAlternatives; } |
| 406 | 970 | ||
| 407 | //BooleanSymbol | 971 | //Reference |
| 408 | public RuleCall getBooleanSymbolParserRuleCall_0() { return cBooleanSymbolParserRuleCall_0; } | 972 | public RuleCall getReferenceParserRuleCall_0() { return cReferenceParserRuleCall_0; } |
| 973 | |||
| 974 | //Call | ||
| 975 | public RuleCall getCallParserRuleCall_1() { return cCallParserRuleCall_1; } | ||
| 409 | 976 | ||
| 410 | //IntegerSymbol | 977 | //Interval |
| 411 | public RuleCall getIntegerSymbolParserRuleCall_1() { return cIntegerSymbolParserRuleCall_1; } | 978 | public RuleCall getIntervalParserRuleCall_2() { return cIntervalParserRuleCall_2; } |
| 979 | |||
| 980 | //Literal | ||
| 981 | public RuleCall getLiteralParserRuleCall_3() { return cLiteralParserRuleCall_3; } | ||
| 412 | 982 | ||
| 413 | //RealSymbol | 983 | //"(" Expression ")" |
| 414 | public RuleCall getRealSymbolParserRuleCall_2() { return cRealSymbolParserRuleCall_2; } | 984 | public Group getGroup_4() { return cGroup_4; } |
| 415 | 985 | ||
| 416 | //StringSymbol | 986 | //"(" |
| 417 | public RuleCall getStringSymbolParserRuleCall_3() { return cStringSymbolParserRuleCall_3; } | 987 | public Keyword getLeftParenthesisKeyword_4_0() { return cLeftParenthesisKeyword_4_0; } |
| 988 | |||
| 989 | //Expression | ||
| 990 | public RuleCall getExpressionParserRuleCall_4_1() { return cExpressionParserRuleCall_4_1; } | ||
| 991 | |||
| 992 | //")" | ||
| 993 | public Keyword getRightParenthesisKeyword_4_2() { return cRightParenthesisKeyword_4_2; } | ||
| 418 | } | 994 | } |
| 419 | public class BooleanSymbolElements extends AbstractParserRuleElementFinder { | 995 | public class CallElements extends AbstractParserRuleElementFinder { |
| 420 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanSymbol"); | 996 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
| 421 | private final Group cGroup = (Group)rule.eContents().get(1); | 997 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 422 | private final Keyword cBoolKeyword_0 = (Keyword)cGroup.eContents().get(0); | 998 | private final Assignment cFunctorAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 423 | private final Action cBooleanSymbolAction_1 = (Action)cGroup.eContents().get(1); | 999 | private final RuleCall cFunctorReferenceParserRuleCall_0_0 = (RuleCall)cFunctorAssignment_0.eContents().get(0); |
| 424 | 1000 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | |
| 425 | //BooleanSymbol: | 1001 | private final Assignment cTransitiveClosureAssignment_1_0 = (Assignment)cAlternatives_1.eContents().get(0); |
| 426 | // 'bool' {BooleanSymbol}; | 1002 | private final RuleCall cTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0 = (RuleCall)cTransitiveClosureAssignment_1_0.eContents().get(0); |
| 1003 | private final Assignment cReflexiveTransitiveClosureAssignment_1_1 = (Assignment)cAlternatives_1.eContents().get(1); | ||
| 1004 | private final RuleCall cReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0 = (RuleCall)cReflexiveTransitiveClosureAssignment_1_1.eContents().get(0); | ||
| 1005 | private final Assignment cArgumentListAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 1006 | private final RuleCall cArgumentListArgumentListParserRuleCall_2_0 = (RuleCall)cArgumentListAssignment_2.eContents().get(0); | ||
| 1007 | |||
| 1008 | //Call: | ||
| 1009 | // functor=Reference (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
| 1010 | // argumentList=ArgumentList; | ||
| 427 | @Override public ParserRule getRule() { return rule; } | 1011 | @Override public ParserRule getRule() { return rule; } |
| 428 | 1012 | ||
| 429 | //'bool' {BooleanSymbol} | 1013 | //functor=Reference (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? |
| 1014 | //argumentList=ArgumentList | ||
| 430 | public Group getGroup() { return cGroup; } | 1015 | public Group getGroup() { return cGroup; } |
| 431 | 1016 | ||
| 432 | //'bool' | 1017 | //functor=Reference |
| 433 | public Keyword getBoolKeyword_0() { return cBoolKeyword_0; } | 1018 | public Assignment getFunctorAssignment_0() { return cFunctorAssignment_0; } |
| 1019 | |||
| 1020 | //Reference | ||
| 1021 | public RuleCall getFunctorReferenceParserRuleCall_0_0() { return cFunctorReferenceParserRuleCall_0_0; } | ||
| 1022 | |||
| 1023 | //(transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
| 1024 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
| 1025 | |||
| 1026 | //transitiveClosure?=TRANSITIVE_CLOSURE | ||
| 1027 | public Assignment getTransitiveClosureAssignment_1_0() { return cTransitiveClosureAssignment_1_0; } | ||
| 1028 | |||
| 1029 | //TRANSITIVE_CLOSURE | ||
| 1030 | public RuleCall getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0() { return cTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0; } | ||
| 1031 | |||
| 1032 | //reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE | ||
| 1033 | public Assignment getReflexiveTransitiveClosureAssignment_1_1() { return cReflexiveTransitiveClosureAssignment_1_1; } | ||
| 434 | 1034 | ||
| 435 | //{BooleanSymbol} | 1035 | //REFLEXIVE_TRANSITIVE_CLOSURE |
| 436 | public Action getBooleanSymbolAction_1() { return cBooleanSymbolAction_1; } | 1036 | public RuleCall getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0() { return cReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0; } |
| 1037 | |||
| 1038 | //argumentList=ArgumentList | ||
| 1039 | public Assignment getArgumentListAssignment_2() { return cArgumentListAssignment_2; } | ||
| 1040 | |||
| 1041 | //ArgumentList | ||
| 1042 | public RuleCall getArgumentListArgumentListParserRuleCall_2_0() { return cArgumentListArgumentListParserRuleCall_2_0; } | ||
| 437 | } | 1043 | } |
| 438 | public class IntegerSymbolElements extends AbstractParserRuleElementFinder { | 1044 | public class ArgumentListElements extends AbstractParserRuleElementFinder { |
| 439 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntegerSymbol"); | 1045 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); |
| 440 | private final Group cGroup = (Group)rule.eContents().get(1); | 1046 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 441 | private final Keyword cIntKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1047 | private final Action cArgumentListAction_0 = (Action)cGroup.eContents().get(0); |
| 442 | private final Action cIntegerSymbolAction_1 = (Action)cGroup.eContents().get(1); | 1048 | private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| 1049 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
| 1050 | private final Assignment cArgumentsAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0); | ||
| 1051 | private final RuleCall cArgumentsArgumentParserRuleCall_2_0_0 = (RuleCall)cArgumentsAssignment_2_0.eContents().get(0); | ||
| 1052 | private final Group cGroup_2_1 = (Group)cGroup_2.eContents().get(1); | ||
| 1053 | private final Keyword cCommaKeyword_2_1_0 = (Keyword)cGroup_2_1.eContents().get(0); | ||
| 1054 | private final Assignment cArgumentsAssignment_2_1_1 = (Assignment)cGroup_2_1.eContents().get(1); | ||
| 1055 | private final RuleCall cArgumentsArgumentParserRuleCall_2_1_1_0 = (RuleCall)cArgumentsAssignment_2_1_1.eContents().get(0); | ||
| 1056 | private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
| 443 | 1057 | ||
| 444 | //IntegerSymbol: | 1058 | //ArgumentList: |
| 445 | // 'int' {IntegerSymbol}; | 1059 | // {ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; |
| 446 | @Override public ParserRule getRule() { return rule; } | 1060 | @Override public ParserRule getRule() { return rule; } |
| 447 | 1061 | ||
| 448 | //'int' {IntegerSymbol} | 1062 | //{ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")" |
| 449 | public Group getGroup() { return cGroup; } | 1063 | public Group getGroup() { return cGroup; } |
| 450 | 1064 | ||
| 451 | //'int' | 1065 | //{ArgumentList} |
| 452 | public Keyword getIntKeyword_0() { return cIntKeyword_0; } | 1066 | public Action getArgumentListAction_0() { return cArgumentListAction_0; } |
| 1067 | |||
| 1068 | //"(" | ||
| 1069 | public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; } | ||
| 1070 | |||
| 1071 | //(arguments+=Argument ("," arguments+=Argument)*)? | ||
| 1072 | public Group getGroup_2() { return cGroup_2; } | ||
| 1073 | |||
| 1074 | //arguments+=Argument | ||
| 1075 | public Assignment getArgumentsAssignment_2_0() { return cArgumentsAssignment_2_0; } | ||
| 1076 | |||
| 1077 | //Argument | ||
| 1078 | public RuleCall getArgumentsArgumentParserRuleCall_2_0_0() { return cArgumentsArgumentParserRuleCall_2_0_0; } | ||
| 1079 | |||
| 1080 | //("," arguments+=Argument)* | ||
| 1081 | public Group getGroup_2_1() { return cGroup_2_1; } | ||
| 1082 | |||
| 1083 | //"," | ||
| 1084 | public Keyword getCommaKeyword_2_1_0() { return cCommaKeyword_2_1_0; } | ||
| 1085 | |||
| 1086 | //arguments+=Argument | ||
| 1087 | public Assignment getArgumentsAssignment_2_1_1() { return cArgumentsAssignment_2_1_1; } | ||
| 1088 | |||
| 1089 | //Argument | ||
| 1090 | public RuleCall getArgumentsArgumentParserRuleCall_2_1_1_0() { return cArgumentsArgumentParserRuleCall_2_1_1_0; } | ||
| 1091 | |||
| 1092 | //")" | ||
| 1093 | public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; } | ||
| 1094 | } | ||
| 1095 | public class ArgumentElements extends AbstractParserRuleElementFinder { | ||
| 1096 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
| 1097 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 1098 | private final RuleCall cExpressionArgumentParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
| 1099 | private final RuleCall cStarArgumentParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
| 1100 | private final RuleCall cTypedArgumentParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
| 1101 | private final RuleCall cTypedStarArgumentParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
| 1102 | |||
| 1103 | //Argument: | ||
| 1104 | // ExpressionArgument | StarArgument | TypedArgument | TypedStarArgument; | ||
| 1105 | @Override public ParserRule getRule() { return rule; } | ||
| 1106 | |||
| 1107 | //ExpressionArgument | StarArgument | TypedArgument | TypedStarArgument | ||
| 1108 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1109 | |||
| 1110 | //ExpressionArgument | ||
| 1111 | public RuleCall getExpressionArgumentParserRuleCall_0() { return cExpressionArgumentParserRuleCall_0; } | ||
| 1112 | |||
| 1113 | //StarArgument | ||
| 1114 | public RuleCall getStarArgumentParserRuleCall_1() { return cStarArgumentParserRuleCall_1; } | ||
| 453 | 1115 | ||
| 454 | //{IntegerSymbol} | 1116 | //TypedArgument |
| 455 | public Action getIntegerSymbolAction_1() { return cIntegerSymbolAction_1; } | 1117 | public RuleCall getTypedArgumentParserRuleCall_2() { return cTypedArgumentParserRuleCall_2; } |
| 1118 | |||
| 1119 | //TypedStarArgument | ||
| 1120 | public RuleCall getTypedStarArgumentParserRuleCall_3() { return cTypedStarArgumentParserRuleCall_3; } | ||
| 456 | } | 1121 | } |
| 457 | public class RealSymbolElements extends AbstractParserRuleElementFinder { | 1122 | public class ExpressionArgumentElements extends AbstractParserRuleElementFinder { |
| 458 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealSymbol"); | 1123 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExpressionArgument"); |
| 1124 | private final Assignment cBodyAssignment = (Assignment)rule.eContents().get(1); | ||
| 1125 | private final RuleCall cBodyComparisonExpressionParserRuleCall_0 = (RuleCall)cBodyAssignment.eContents().get(0); | ||
| 1126 | |||
| 1127 | //ExpressionArgument: | ||
| 1128 | // body=ComparisonExpression; | ||
| 1129 | @Override public ParserRule getRule() { return rule; } | ||
| 1130 | |||
| 1131 | //body=ComparisonExpression | ||
| 1132 | public Assignment getBodyAssignment() { return cBodyAssignment; } | ||
| 1133 | |||
| 1134 | //ComparisonExpression | ||
| 1135 | public RuleCall getBodyComparisonExpressionParserRuleCall_0() { return cBodyComparisonExpressionParserRuleCall_0; } | ||
| 1136 | } | ||
| 1137 | public class StarArgumentElements extends AbstractParserRuleElementFinder { | ||
| 1138 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StarArgument"); | ||
| 459 | private final Group cGroup = (Group)rule.eContents().get(1); | 1139 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 460 | private final Keyword cRealKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1140 | private final Action cStarArgumentAction_0 = (Action)cGroup.eContents().get(0); |
| 461 | private final Action cRealSymbolAction_1 = (Action)cGroup.eContents().get(1); | 1141 | private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| 462 | 1142 | ||
| 463 | //RealSymbol: | 1143 | //StarArgument: |
| 464 | // 'real' {RealSymbol}; | 1144 | // {StarArgument} "*"; |
| 465 | @Override public ParserRule getRule() { return rule; } | 1145 | @Override public ParserRule getRule() { return rule; } |
| 466 | 1146 | ||
| 467 | //'real' {RealSymbol} | 1147 | //{StarArgument} "*" |
| 468 | public Group getGroup() { return cGroup; } | 1148 | public Group getGroup() { return cGroup; } |
| 469 | 1149 | ||
| 470 | //'real' | 1150 | //{StarArgument} |
| 471 | public Keyword getRealKeyword_0() { return cRealKeyword_0; } | 1151 | public Action getStarArgumentAction_0() { return cStarArgumentAction_0; } |
| 472 | 1152 | ||
| 473 | //{RealSymbol} | 1153 | //"*" |
| 474 | public Action getRealSymbolAction_1() { return cRealSymbolAction_1; } | 1154 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } |
| 475 | } | 1155 | } |
| 476 | public class StringSymbolElements extends AbstractParserRuleElementFinder { | 1156 | public class TypedArgumentElements extends AbstractParserRuleElementFinder { |
| 477 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringSymbol"); | 1157 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TypedArgument"); |
| 478 | private final Group cGroup = (Group)rule.eContents().get(1); | 1158 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 479 | private final Keyword cStringKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1159 | private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 480 | private final Action cStringSymbolAction_1 = (Action)cGroup.eContents().get(1); | 1160 | private final CrossReference cTypeNamedElementCrossReference_0_0 = (CrossReference)cTypeAssignment_0.eContents().get(0); |
| 481 | 1161 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cTypeNamedElementCrossReference_0_0.eContents().get(1); | |
| 482 | //StringSymbol: | 1162 | private final Assignment cVariableAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 483 | // 'string' {StringSymbol}; | 1163 | private final CrossReference cVariableNamedElementCrossReference_1_0 = (CrossReference)cVariableAssignment_1.eContents().get(0); |
| 1164 | private final RuleCall cVariableNamedElementQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cVariableNamedElementCrossReference_1_0.eContents().get(1); | ||
| 1165 | |||
| 1166 | //TypedArgument: | ||
| 1167 | // type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName]; | ||
| 484 | @Override public ParserRule getRule() { return rule; } | 1168 | @Override public ParserRule getRule() { return rule; } |
| 485 | 1169 | ||
| 486 | //'string' {StringSymbol} | 1170 | //type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName] |
| 487 | public Group getGroup() { return cGroup; } | 1171 | public Group getGroup() { return cGroup; } |
| 488 | 1172 | ||
| 489 | //'string' | 1173 | //type=[NamedElement|QualifiedName] |
| 490 | public Keyword getStringKeyword_0() { return cStringKeyword_0; } | 1174 | public Assignment getTypeAssignment_0() { return cTypeAssignment_0; } |
| 1175 | |||
| 1176 | //[NamedElement|QualifiedName] | ||
| 1177 | public CrossReference getTypeNamedElementCrossReference_0_0() { return cTypeNamedElementCrossReference_0_0; } | ||
| 1178 | |||
| 1179 | //QualifiedName | ||
| 1180 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_0_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_0_0_1; } | ||
| 1181 | |||
| 1182 | //variable=[NamedElement|QualifiedName] | ||
| 1183 | public Assignment getVariableAssignment_1() { return cVariableAssignment_1; } | ||
| 1184 | |||
| 1185 | //[NamedElement|QualifiedName] | ||
| 1186 | public CrossReference getVariableNamedElementCrossReference_1_0() { return cVariableNamedElementCrossReference_1_0; } | ||
| 491 | 1187 | ||
| 492 | //{StringSymbol} | 1188 | //QualifiedName |
| 493 | public Action getStringSymbolAction_1() { return cStringSymbolAction_1; } | 1189 | public RuleCall getVariableNamedElementQualifiedNameParserRuleCall_1_0_1() { return cVariableNamedElementQualifiedNameParserRuleCall_1_0_1; } |
| 494 | } | 1190 | } |
| 495 | public class ComplexObjectElements extends AbstractParserRuleElementFinder { | 1191 | public class TypedStarArgumentElements extends AbstractParserRuleElementFinder { |
| 496 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); | 1192 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TypedStarArgument"); |
| 497 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1193 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 498 | private final RuleCall cObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 1194 | private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 499 | private final RuleCall cAllInstancesParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 1195 | private final CrossReference cTypeNamedElementCrossReference_0_0 = (CrossReference)cTypeAssignment_0.eContents().get(0); |
| 500 | private final RuleCall cAllObjectsParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 1196 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cTypeNamedElementCrossReference_0_0.eContents().get(1); |
| 1197 | private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 501 | 1198 | ||
| 502 | //ComplexObject: | 1199 | //TypedStarArgument: |
| 503 | // Object | AllInstances | AllObjects; | 1200 | // type=[NamedElement|QualifiedName] "*"; |
| 504 | @Override public ParserRule getRule() { return rule; } | 1201 | @Override public ParserRule getRule() { return rule; } |
| 505 | 1202 | ||
| 506 | //Object | AllInstances | AllObjects | 1203 | //type=[NamedElement|QualifiedName] "*" |
| 507 | public Alternatives getAlternatives() { return cAlternatives; } | 1204 | public Group getGroup() { return cGroup; } |
| 508 | 1205 | ||
| 509 | //Object | 1206 | //type=[NamedElement|QualifiedName] |
| 510 | public RuleCall getObjectParserRuleCall_0() { return cObjectParserRuleCall_0; } | 1207 | public Assignment getTypeAssignment_0() { return cTypeAssignment_0; } |
| 511 | 1208 | ||
| 512 | //AllInstances | 1209 | //[NamedElement|QualifiedName] |
| 513 | public RuleCall getAllInstancesParserRuleCall_1() { return cAllInstancesParserRuleCall_1; } | 1210 | public CrossReference getTypeNamedElementCrossReference_0_0() { return cTypeNamedElementCrossReference_0_0; } |
| 514 | 1211 | ||
| 515 | //AllObjects | 1212 | //QualifiedName |
| 516 | public RuleCall getAllObjectsParserRuleCall_2() { return cAllObjectsParserRuleCall_2; } | 1213 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_0_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_0_0_1; } |
| 1214 | |||
| 1215 | //"*" | ||
| 1216 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } | ||
| 517 | } | 1217 | } |
| 518 | public class ObjectElements extends AbstractParserRuleElementFinder { | 1218 | public class ReferenceElements extends AbstractParserRuleElementFinder { |
| 519 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Object"); | 1219 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); |
| 520 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1220 | private final Assignment cReferredAssignment = (Assignment)rule.eContents().get(1); |
| 521 | private final RuleCall cNamedObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 1221 | private final CrossReference cReferredNamedElementCrossReference_0 = (CrossReference)cReferredAssignment.eContents().get(0); |
| 522 | private final RuleCall cUnnamedObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 1222 | private final RuleCall cReferredNamedElementQualifiedNameParserRuleCall_0_1 = (RuleCall)cReferredNamedElementCrossReference_0.eContents().get(1); |
| 523 | private final RuleCall cDataObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
| 524 | 1223 | ||
| 525 | //Object: | 1224 | //Reference: |
| 526 | // NamedObject | UnnamedObject | DataObject; | 1225 | // referred=[NamedElement|QualifiedName]; |
| 527 | @Override public ParserRule getRule() { return rule; } | 1226 | @Override public ParserRule getRule() { return rule; } |
| 528 | 1227 | ||
| 529 | //NamedObject | UnnamedObject | DataObject | 1228 | //referred=[NamedElement|QualifiedName] |
| 530 | public Alternatives getAlternatives() { return cAlternatives; } | 1229 | public Assignment getReferredAssignment() { return cReferredAssignment; } |
| 531 | |||
| 532 | //NamedObject | ||
| 533 | public RuleCall getNamedObjectParserRuleCall_0() { return cNamedObjectParserRuleCall_0; } | ||
| 534 | 1230 | ||
| 535 | //UnnamedObject | 1231 | //[NamedElement|QualifiedName] |
| 536 | public RuleCall getUnnamedObjectParserRuleCall_1() { return cUnnamedObjectParserRuleCall_1; } | 1232 | public CrossReference getReferredNamedElementCrossReference_0() { return cReferredNamedElementCrossReference_0; } |
| 537 | 1233 | ||
| 538 | //DataObject | 1234 | //QualifiedName |
| 539 | public RuleCall getDataObjectParserRuleCall_2() { return cDataObjectParserRuleCall_2; } | 1235 | public RuleCall getReferredNamedElementQualifiedNameParserRuleCall_0_1() { return cReferredNamedElementQualifiedNameParserRuleCall_0_1; } |
| 540 | } | 1236 | } |
| 541 | public class NamedObjectElements extends AbstractParserRuleElementFinder { | 1237 | public class IntervalElements extends AbstractParserRuleElementFinder { |
| 542 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); | 1238 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Interval"); |
| 543 | private final Group cGroup = (Group)rule.eContents().get(1); | 1239 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 544 | private final Keyword cApostropheKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1240 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 545 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); | 1241 | private final Assignment cLowerBoundAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 546 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); | 1242 | private final RuleCall cLowerBoundExpressionParserRuleCall_1_0 = (RuleCall)cLowerBoundAssignment_1.eContents().get(0); |
| 547 | private final Keyword cApostropheKeyword_2 = (Keyword)cGroup.eContents().get(2); | 1243 | private final Keyword cFullStopFullStopKeyword_2 = (Keyword)cGroup.eContents().get(2); |
| 548 | 1244 | private final Assignment cUpperBoundAssignment_3 = (Assignment)cGroup.eContents().get(3); | |
| 549 | //NamedObject: | 1245 | private final RuleCall cUpperBoundExpressionParserRuleCall_3_0 = (RuleCall)cUpperBoundAssignment_3.eContents().get(0); |
| 550 | // "'" name=ID "'"; | 1246 | private final Keyword cRightSquareBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); |
| 1247 | |||
| 1248 | //Interval: | ||
| 1249 | // "[" lowerBound=Expression ".." upperBound=Expression "]"; | ||
| 551 | @Override public ParserRule getRule() { return rule; } | 1250 | @Override public ParserRule getRule() { return rule; } |
| 552 | 1251 | ||
| 553 | //"'" name=ID "'" | 1252 | //"[" lowerBound=Expression ".." upperBound=Expression "]" |
| 554 | public Group getGroup() { return cGroup; } | 1253 | public Group getGroup() { return cGroup; } |
| 555 | 1254 | ||
| 556 | //"'" | 1255 | //"[" |
| 557 | public Keyword getApostropheKeyword_0() { return cApostropheKeyword_0; } | 1256 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } |
| 558 | 1257 | ||
| 559 | //name=ID | 1258 | //lowerBound=Expression |
| 560 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } | 1259 | public Assignment getLowerBoundAssignment_1() { return cLowerBoundAssignment_1; } |
| 561 | 1260 | ||
| 562 | //ID | 1261 | //Expression |
| 563 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } | 1262 | public RuleCall getLowerBoundExpressionParserRuleCall_1_0() { return cLowerBoundExpressionParserRuleCall_1_0; } |
| 564 | 1263 | ||
| 565 | //"'" | 1264 | //".." |
| 566 | public Keyword getApostropheKeyword_2() { return cApostropheKeyword_2; } | 1265 | public Keyword getFullStopFullStopKeyword_2() { return cFullStopFullStopKeyword_2; } |
| 567 | } | ||
| 568 | public class UnnamedObjectElements extends AbstractParserRuleElementFinder { | ||
| 569 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnnamedObject"); | ||
| 570 | private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); | ||
| 571 | private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); | ||
| 572 | 1266 | ||
| 573 | //UnnamedObject: | 1267 | //upperBound=Expression |
| 574 | // name=ID; | 1268 | public Assignment getUpperBoundAssignment_3() { return cUpperBoundAssignment_3; } |
| 575 | @Override public ParserRule getRule() { return rule; } | ||
| 576 | 1269 | ||
| 577 | //name=ID | 1270 | //Expression |
| 578 | public Assignment getNameAssignment() { return cNameAssignment; } | 1271 | public RuleCall getUpperBoundExpressionParserRuleCall_3_0() { return cUpperBoundExpressionParserRuleCall_3_0; } |
| 579 | 1272 | ||
| 580 | //ID | 1273 | //"]" |
| 581 | public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } | 1274 | public Keyword getRightSquareBracketKeyword_4() { return cRightSquareBracketKeyword_4; } |
| 582 | } | 1275 | } |
| 583 | public class DataObjectElements extends AbstractParserRuleElementFinder { | 1276 | public class LiteralElements extends AbstractParserRuleElementFinder { |
| 584 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataObject"); | 1277 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); |
| 585 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1278 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 586 | private final RuleCall cBooleanObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 1279 | private final RuleCall cLogicLiteralParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 587 | private final RuleCall cIntObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 1280 | private final RuleCall cNumericLiteralParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 588 | private final RuleCall cRealObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 1281 | private final RuleCall cInfinityLiteralParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); |
| 589 | private final RuleCall cStringObjectParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | 1282 | private final RuleCall cEmptyIntervalLiteralParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); |
| 1283 | private final RuleCall cStringLiteralParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); | ||
| 590 | 1284 | ||
| 591 | //DataObject: | 1285 | //Literal: |
| 592 | // BooleanObject | IntObject | RealObject | StringObject; | 1286 | // LogicLiteral | NumericLiteral | InfinityLiteral | EmptyIntervalLiteral | StringLiteral; |
| 593 | @Override public ParserRule getRule() { return rule; } | 1287 | @Override public ParserRule getRule() { return rule; } |
| 594 | 1288 | ||
| 595 | //BooleanObject | IntObject | RealObject | StringObject | 1289 | //LogicLiteral | NumericLiteral | InfinityLiteral | EmptyIntervalLiteral | StringLiteral |
| 596 | public Alternatives getAlternatives() { return cAlternatives; } | 1290 | public Alternatives getAlternatives() { return cAlternatives; } |
| 597 | 1291 | ||
| 598 | //BooleanObject | 1292 | //LogicLiteral |
| 599 | public RuleCall getBooleanObjectParserRuleCall_0() { return cBooleanObjectParserRuleCall_0; } | 1293 | public RuleCall getLogicLiteralParserRuleCall_0() { return cLogicLiteralParserRuleCall_0; } |
| 1294 | |||
| 1295 | //NumericLiteral | ||
| 1296 | public RuleCall getNumericLiteralParserRuleCall_1() { return cNumericLiteralParserRuleCall_1; } | ||
| 600 | 1297 | ||
| 601 | //IntObject | 1298 | //InfinityLiteral |
| 602 | public RuleCall getIntObjectParserRuleCall_1() { return cIntObjectParserRuleCall_1; } | 1299 | public RuleCall getInfinityLiteralParserRuleCall_2() { return cInfinityLiteralParserRuleCall_2; } |
| 603 | 1300 | ||
| 604 | //RealObject | 1301 | //EmptyIntervalLiteral |
| 605 | public RuleCall getRealObjectParserRuleCall_2() { return cRealObjectParserRuleCall_2; } | 1302 | public RuleCall getEmptyIntervalLiteralParserRuleCall_3() { return cEmptyIntervalLiteralParserRuleCall_3; } |
| 606 | 1303 | ||
| 607 | //StringObject | 1304 | //StringLiteral |
| 608 | public RuleCall getStringObjectParserRuleCall_3() { return cStringObjectParserRuleCall_3; } | 1305 | public RuleCall getStringLiteralParserRuleCall_4() { return cStringLiteralParserRuleCall_4; } |
| 609 | } | 1306 | } |
| 610 | public class BooleanObjectElements extends AbstractParserRuleElementFinder { | 1307 | public class LogicLiteralElements extends AbstractParserRuleElementFinder { |
| 611 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanObject"); | 1308 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LogicLiteral"); |
| 612 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | 1309 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); |
| 613 | private final RuleCall cValueBooleanValueParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | 1310 | private final RuleCall cValueLogicValueEnumRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); |
| 614 | 1311 | ||
| 615 | //BooleanObject: | 1312 | //LogicLiteral: |
| 616 | // value=BooleanValue; | 1313 | // value=LogicValue; |
| 617 | @Override public ParserRule getRule() { return rule; } | 1314 | @Override public ParserRule getRule() { return rule; } |
| 618 | 1315 | ||
| 619 | //value=BooleanValue | 1316 | //value=LogicValue |
| 620 | public Assignment getValueAssignment() { return cValueAssignment; } | 1317 | public Assignment getValueAssignment() { return cValueAssignment; } |
| 621 | 1318 | ||
| 622 | //BooleanValue | 1319 | //LogicValue |
| 623 | public RuleCall getValueBooleanValueParserRuleCall_0() { return cValueBooleanValueParserRuleCall_0; } | 1320 | public RuleCall getValueLogicValueEnumRuleCall_0() { return cValueLogicValueEnumRuleCall_0; } |
| 624 | } | 1321 | } |
| 625 | public class IntObjectElements extends AbstractParserRuleElementFinder { | 1322 | public class NumericLiteralElements extends AbstractParserRuleElementFinder { |
| 626 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntObject"); | 1323 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NumericLiteral"); |
| 627 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | 1324 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); |
| 628 | private final RuleCall cValueINTLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | 1325 | private final RuleCall cValueRealParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); |
| 629 | 1326 | ||
| 630 | //IntObject: | 1327 | //NumericLiteral: |
| 631 | // value=INTLiteral; | 1328 | // value=Real; |
| 632 | @Override public ParserRule getRule() { return rule; } | 1329 | @Override public ParserRule getRule() { return rule; } |
| 633 | 1330 | ||
| 634 | //value=INTLiteral | 1331 | //value=Real |
| 635 | public Assignment getValueAssignment() { return cValueAssignment; } | 1332 | public Assignment getValueAssignment() { return cValueAssignment; } |
| 636 | 1333 | ||
| 637 | //INTLiteral | 1334 | //Real |
| 638 | public RuleCall getValueINTLiteralParserRuleCall_0() { return cValueINTLiteralParserRuleCall_0; } | 1335 | public RuleCall getValueRealParserRuleCall_0() { return cValueRealParserRuleCall_0; } |
| 639 | } | 1336 | } |
| 640 | public class RealObjectElements extends AbstractParserRuleElementFinder { | 1337 | public class InfinityLiteralElements extends AbstractParserRuleElementFinder { |
| 641 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealObject"); | 1338 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.InfinityLiteral"); |
| 642 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | 1339 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 643 | private final RuleCall cValueREALLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | 1340 | private final Action cInfinityLiteralAction_0 = (Action)cGroup.eContents().get(0); |
| 1341 | private final Keyword cInfKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 644 | 1342 | ||
| 645 | //RealObject: | 1343 | //InfinityLiteral: |
| 646 | // value=REALLiteral; | 1344 | // {InfinityLiteral} "inf"; |
| 647 | @Override public ParserRule getRule() { return rule; } | 1345 | @Override public ParserRule getRule() { return rule; } |
| 648 | 1346 | ||
| 649 | //value=REALLiteral | 1347 | //{InfinityLiteral} "inf" |
| 650 | public Assignment getValueAssignment() { return cValueAssignment; } | 1348 | public Group getGroup() { return cGroup; } |
| 1349 | |||
| 1350 | //{InfinityLiteral} | ||
| 1351 | public Action getInfinityLiteralAction_0() { return cInfinityLiteralAction_0; } | ||
| 651 | 1352 | ||
| 652 | //REALLiteral | 1353 | //"inf" |
| 653 | public RuleCall getValueREALLiteralParserRuleCall_0() { return cValueREALLiteralParserRuleCall_0; } | 1354 | public Keyword getInfKeyword_1() { return cInfKeyword_1; } |
| 654 | } | 1355 | } |
| 655 | public class StringObjectElements extends AbstractParserRuleElementFinder { | 1356 | public class EmptyIntervalLiteralElements extends AbstractParserRuleElementFinder { |
| 656 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringObject"); | 1357 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EmptyIntervalLiteral"); |
| 1358 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 1359 | private final Action cEmptyIntervalLiteralAction_0 = (Action)cGroup.eContents().get(0); | ||
| 1360 | private final Keyword cEmptyKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 1361 | |||
| 1362 | //EmptyIntervalLiteral: | ||
| 1363 | // {EmptyIntervalLiteral} "empty"; | ||
| 1364 | @Override public ParserRule getRule() { return rule; } | ||
| 1365 | |||
| 1366 | //{EmptyIntervalLiteral} "empty" | ||
| 1367 | public Group getGroup() { return cGroup; } | ||
| 1368 | |||
| 1369 | //{EmptyIntervalLiteral} | ||
| 1370 | public Action getEmptyIntervalLiteralAction_0() { return cEmptyIntervalLiteralAction_0; } | ||
| 1371 | |||
| 1372 | //"empty" | ||
| 1373 | public Keyword getEmptyKeyword_1() { return cEmptyKeyword_1; } | ||
| 1374 | } | ||
| 1375 | public class StringLiteralElements extends AbstractParserRuleElementFinder { | ||
| 1376 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringLiteral"); | ||
| 657 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | 1377 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); |
| 658 | private final RuleCall cValueSTRINGTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | 1378 | private final RuleCall cValueSTRINGTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); |
| 659 | 1379 | ||
| 660 | //StringObject: | 1380 | //StringLiteral: |
| 661 | // value=STRING; | 1381 | // value=STRING; |
| 662 | @Override public ParserRule getRule() { return rule; } | 1382 | @Override public ParserRule getRule() { return rule; } |
| 663 | 1383 | ||
| @@ -667,817 +1387,1181 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 667 | //STRING | 1387 | //STRING |
| 668 | public RuleCall getValueSTRINGTerminalRuleCall_0() { return cValueSTRINGTerminalRuleCall_0; } | 1388 | public RuleCall getValueSTRINGTerminalRuleCall_0() { return cValueSTRINGTerminalRuleCall_0; } |
| 669 | } | 1389 | } |
| 670 | public class PredicateElements extends AbstractParserRuleElementFinder { | 1390 | public class ClassDefinitionElements extends AbstractParserRuleElementFinder { |
| 671 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Predicate"); | 1391 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClassDefinition"); |
| 672 | private final Group cGroup = (Group)rule.eContents().get(1); | 1392 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 673 | private final Assignment cIsErrorAssignment_0 = (Assignment)cGroup.eContents().get(0); | 1393 | private final Assignment cAbstractAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 674 | private final Keyword cIsErrorErrorKeyword_0_0 = (Keyword)cIsErrorAssignment_0.eContents().get(0); | 1394 | private final Keyword cAbstractAbstractKeyword_0_0 = (Keyword)cAbstractAssignment_0.eContents().get(0); |
| 675 | private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); | 1395 | private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| 676 | private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); | 1396 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); |
| 677 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | 1397 | private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); |
| 678 | private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); | 1398 | private final Group cGroup_3 = (Group)cGroup.eContents().get(3); |
| 679 | private final Group cGroup_2_1 = (Group)cGroup_2.eContents().get(1); | 1399 | private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); |
| 680 | private final Assignment cParametersAssignment_2_1_0 = (Assignment)cGroup_2_1.eContents().get(0); | 1400 | private final Assignment cSuperclassesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); |
| 681 | private final RuleCall cParametersParameterParserRuleCall_2_1_0_0 = (RuleCall)cParametersAssignment_2_1_0.eContents().get(0); | 1401 | private final CrossReference cSuperclassesNamedElementCrossReference_3_1_0 = (CrossReference)cSuperclassesAssignment_3_1.eContents().get(0); |
| 682 | private final Group cGroup_2_1_1 = (Group)cGroup_2_1.eContents().get(1); | 1402 | private final RuleCall cSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1 = (RuleCall)cSuperclassesNamedElementCrossReference_3_1_0.eContents().get(1); |
| 683 | private final Keyword cCommaKeyword_2_1_1_0 = (Keyword)cGroup_2_1_1.eContents().get(0); | 1403 | private final Group cGroup_3_2 = (Group)cGroup_3.eContents().get(2); |
| 684 | private final Assignment cParametersAssignment_2_1_1_1 = (Assignment)cGroup_2_1_1.eContents().get(1); | 1404 | private final Keyword cCommaKeyword_3_2_0 = (Keyword)cGroup_3_2.eContents().get(0); |
| 685 | private final RuleCall cParametersParameterParserRuleCall_2_1_1_1_0 = (RuleCall)cParametersAssignment_2_1_1_1.eContents().get(0); | 1405 | private final Assignment cSuperclassesAssignment_3_2_1 = (Assignment)cGroup_3_2.eContents().get(1); |
| 686 | private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2); | 1406 | private final CrossReference cSuperclassesNamedElementCrossReference_3_2_1_0 = (CrossReference)cSuperclassesAssignment_3_2_1.eContents().get(0); |
| 687 | private final Keyword cColonHyphenMinusKeyword_3 = (Keyword)cGroup.eContents().get(3); | 1407 | private final RuleCall cSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1 = (RuleCall)cSuperclassesNamedElementCrossReference_3_2_1_0.eContents().get(1); |
| 688 | private final Alternatives cAlternatives_4 = (Alternatives)cGroup.eContents().get(4); | 1408 | private final Keyword cLeftCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); |
| 689 | private final Keyword cFalseKeyword_4_0 = (Keyword)cAlternatives_4.eContents().get(0); | 1409 | private final Assignment cMembersAssignment_5 = (Assignment)cGroup.eContents().get(5); |
| 690 | private final Group cGroup_4_1 = (Group)cAlternatives_4.eContents().get(1); | 1410 | private final RuleCall cMembersMemberDefinitionParserRuleCall_5_0 = (RuleCall)cMembersAssignment_5.eContents().get(0); |
| 691 | private final Assignment cBodiesAssignment_4_1_0 = (Assignment)cGroup_4_1.eContents().get(0); | 1411 | private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6); |
| 692 | private final RuleCall cBodiesPatternBodyParserRuleCall_4_1_0_0 = (RuleCall)cBodiesAssignment_4_1_0.eContents().get(0); | 1412 | |
| 693 | private final Group cGroup_4_1_1 = (Group)cGroup_4_1.eContents().get(1); | 1413 | //ClassDefinition: |
| 694 | private final Keyword cVerticalLineKeyword_4_1_1_0 = (Keyword)cGroup_4_1_1.eContents().get(0); | 1414 | // abstract?="abstract"? "class" name=ID ("extends" superclasses+=[NamedElement|QualifiedName] ("," |
| 695 | private final Assignment cBodiesAssignment_4_1_1_1 = (Assignment)cGroup_4_1_1.eContents().get(1); | 1415 | // superclasses+=[NamedElement|QualifiedName])*)? |
| 696 | private final RuleCall cBodiesPatternBodyParserRuleCall_4_1_1_1_0 = (RuleCall)cBodiesAssignment_4_1_1_1.eContents().get(0); | 1416 | // "{" members+=MemberDefinition* "}"; |
| 697 | private final Keyword cFullStopKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
| 698 | |||
| 699 | ///////////////////// | ||
| 700 | //// Predicte grammar | ||
| 701 | ///////////////////// | ||
| 702 | //Predicate: | ||
| 703 | // isError?='error'? symbol=ModelSymbol ('(' (parameters+=Parameter (',' parameters+=Parameter)*)? ')')? ':-' ('false' | | ||
| 704 | // bodies+=PatternBody ('|' bodies+=PatternBody)*) '.'; | ||
| 705 | @Override public ParserRule getRule() { return rule; } | 1417 | @Override public ParserRule getRule() { return rule; } |
| 706 | 1418 | ||
| 707 | //isError?='error'? symbol=ModelSymbol ('(' (parameters+=Parameter (',' parameters+=Parameter)*)? ')')? ':-' ('false' | | 1419 | //abstract?="abstract"? "class" name=ID ("extends" superclasses+=[NamedElement|QualifiedName] ("," |
| 708 | //bodies+=PatternBody ('|' bodies+=PatternBody)*) '.' | 1420 | //superclasses+=[NamedElement|QualifiedName])*)? "{" members+=MemberDefinition* "}" |
| 709 | public Group getGroup() { return cGroup; } | 1421 | public Group getGroup() { return cGroup; } |
| 710 | 1422 | ||
| 711 | //isError?='error'? | 1423 | //abstract?="abstract"? |
| 712 | public Assignment getIsErrorAssignment_0() { return cIsErrorAssignment_0; } | 1424 | public Assignment getAbstractAssignment_0() { return cAbstractAssignment_0; } |
| 713 | 1425 | ||
| 714 | //'error' | 1426 | //"abstract" |
| 715 | public Keyword getIsErrorErrorKeyword_0_0() { return cIsErrorErrorKeyword_0_0; } | 1427 | public Keyword getAbstractAbstractKeyword_0_0() { return cAbstractAbstractKeyword_0_0; } |
| 716 | 1428 | ||
| 717 | //symbol=ModelSymbol | 1429 | //"class" |
| 718 | public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } | 1430 | public Keyword getClassKeyword_1() { return cClassKeyword_1; } |
| 719 | 1431 | ||
| 720 | //ModelSymbol | 1432 | //name=ID |
| 721 | public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } | 1433 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } |
| 722 | 1434 | ||
| 723 | //('(' (parameters+=Parameter (',' parameters+=Parameter)*)? ')')? | 1435 | //ID |
| 724 | public Group getGroup_2() { return cGroup_2; } | 1436 | public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; } |
| 725 | 1437 | ||
| 726 | //'(' | 1438 | //("extends" superclasses+=[NamedElement|QualifiedName] ("," superclasses+=[NamedElement|QualifiedName])*)? |
| 727 | public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; } | 1439 | public Group getGroup_3() { return cGroup_3; } |
| 728 | 1440 | ||
| 729 | //(parameters+=Parameter (',' parameters+=Parameter)*)? | 1441 | //"extends" |
| 730 | public Group getGroup_2_1() { return cGroup_2_1; } | 1442 | public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; } |
| 1443 | |||
| 1444 | //superclasses+=[NamedElement|QualifiedName] | ||
| 1445 | public Assignment getSuperclassesAssignment_3_1() { return cSuperclassesAssignment_3_1; } | ||
| 1446 | |||
| 1447 | //[NamedElement|QualifiedName] | ||
| 1448 | public CrossReference getSuperclassesNamedElementCrossReference_3_1_0() { return cSuperclassesNamedElementCrossReference_3_1_0; } | ||
| 1449 | |||
| 1450 | //QualifiedName | ||
| 1451 | public RuleCall getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1() { return cSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1; } | ||
| 1452 | |||
| 1453 | //("," superclasses+=[NamedElement|QualifiedName])* | ||
| 1454 | public Group getGroup_3_2() { return cGroup_3_2; } | ||
| 1455 | |||
| 1456 | //"," | ||
| 1457 | public Keyword getCommaKeyword_3_2_0() { return cCommaKeyword_3_2_0; } | ||
| 1458 | |||
| 1459 | //superclasses+=[NamedElement|QualifiedName] | ||
| 1460 | public Assignment getSuperclassesAssignment_3_2_1() { return cSuperclassesAssignment_3_2_1; } | ||
| 1461 | |||
| 1462 | //[NamedElement|QualifiedName] | ||
| 1463 | public CrossReference getSuperclassesNamedElementCrossReference_3_2_1_0() { return cSuperclassesNamedElementCrossReference_3_2_1_0; } | ||
| 1464 | |||
| 1465 | //QualifiedName | ||
| 1466 | public RuleCall getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1() { return cSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1; } | ||
| 1467 | |||
| 1468 | //"{" | ||
| 1469 | public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; } | ||
| 1470 | |||
| 1471 | //members+=MemberDefinition* | ||
| 1472 | public Assignment getMembersAssignment_5() { return cMembersAssignment_5; } | ||
| 1473 | |||
| 1474 | //MemberDefinition | ||
| 1475 | public RuleCall getMembersMemberDefinitionParserRuleCall_5_0() { return cMembersMemberDefinitionParserRuleCall_5_0; } | ||
| 731 | 1476 | ||
| 732 | //parameters+=Parameter | 1477 | //"}" |
| 733 | public Assignment getParametersAssignment_2_1_0() { return cParametersAssignment_2_1_0; } | 1478 | public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; } |
| 1479 | } | ||
| 1480 | public class MemberDefinitionElements extends AbstractParserRuleElementFinder { | ||
| 1481 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); | ||
| 1482 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 1483 | private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
| 1484 | private final Keyword cContainmentContainsKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0); | ||
| 1485 | private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 1486 | private final CrossReference cTypeNamedElementCrossReference_1_0 = (CrossReference)cTypeAssignment_1.eContents().get(0); | ||
| 1487 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_0.eContents().get(1); | ||
| 1488 | private final Assignment cMultiplicityAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 1489 | private final RuleCall cMultiplicityMultiplicityParserRuleCall_2_0 = (RuleCall)cMultiplicityAssignment_2.eContents().get(0); | ||
| 1490 | private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 1491 | private final RuleCall cNameIDTerminalRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); | ||
| 1492 | private final Group cGroup_4 = (Group)cGroup.eContents().get(4); | ||
| 1493 | private final Keyword cOppositeKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); | ||
| 1494 | private final Assignment cOppositeAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); | ||
| 1495 | private final CrossReference cOppositeNamedElementCrossReference_4_1_0 = (CrossReference)cOppositeAssignment_4_1.eContents().get(0); | ||
| 1496 | private final RuleCall cOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1 = (RuleCall)cOppositeNamedElementCrossReference_4_1_0.eContents().get(1); | ||
| 1497 | private final Keyword cSemicolonKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
| 1498 | |||
| 1499 | //MemberDefinition: | ||
| 1500 | // containment?="contains"? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID ("opposite" | ||
| 1501 | // opposite=[NamedElement|QualifiedName])? ";"?; | ||
| 1502 | @Override public ParserRule getRule() { return rule; } | ||
| 734 | 1503 | ||
| 735 | //Parameter | 1504 | //containment?="contains"? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID ("opposite" |
| 736 | public RuleCall getParametersParameterParserRuleCall_2_1_0_0() { return cParametersParameterParserRuleCall_2_1_0_0; } | 1505 | //opposite=[NamedElement|QualifiedName])? ";"? |
| 1506 | public Group getGroup() { return cGroup; } | ||
| 737 | 1507 | ||
| 738 | //(',' parameters+=Parameter)* | 1508 | //containment?="contains"? |
| 739 | public Group getGroup_2_1_1() { return cGroup_2_1_1; } | 1509 | public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; } |
| 740 | 1510 | ||
| 741 | //',' | 1511 | //"contains" |
| 742 | public Keyword getCommaKeyword_2_1_1_0() { return cCommaKeyword_2_1_1_0; } | 1512 | public Keyword getContainmentContainsKeyword_0_0() { return cContainmentContainsKeyword_0_0; } |
| 743 | 1513 | ||
| 744 | //parameters+=Parameter | 1514 | //type=[NamedElement|QualifiedName] |
| 745 | public Assignment getParametersAssignment_2_1_1_1() { return cParametersAssignment_2_1_1_1; } | 1515 | public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } |
| 746 | 1516 | ||
| 747 | //Parameter | 1517 | //[NamedElement|QualifiedName] |
| 748 | public RuleCall getParametersParameterParserRuleCall_2_1_1_1_0() { return cParametersParameterParserRuleCall_2_1_1_1_0; } | 1518 | public CrossReference getTypeNamedElementCrossReference_1_0() { return cTypeNamedElementCrossReference_1_0; } |
| 749 | 1519 | ||
| 750 | //')' | 1520 | //QualifiedName |
| 751 | public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; } | 1521 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_0_1; } |
| 752 | 1522 | ||
| 753 | //':-' | 1523 | //multiplicity=Multiplicity? |
| 754 | public Keyword getColonHyphenMinusKeyword_3() { return cColonHyphenMinusKeyword_3; } | 1524 | public Assignment getMultiplicityAssignment_2() { return cMultiplicityAssignment_2; } |
| 755 | 1525 | ||
| 756 | //'false' | bodies+=PatternBody ('|' bodies+=PatternBody)* | 1526 | //Multiplicity |
| 757 | public Alternatives getAlternatives_4() { return cAlternatives_4; } | 1527 | public RuleCall getMultiplicityMultiplicityParserRuleCall_2_0() { return cMultiplicityMultiplicityParserRuleCall_2_0; } |
| 758 | 1528 | ||
| 759 | //'false' | 1529 | //name=ID |
| 760 | public Keyword getFalseKeyword_4_0() { return cFalseKeyword_4_0; } | 1530 | public Assignment getNameAssignment_3() { return cNameAssignment_3; } |
| 761 | 1531 | ||
| 762 | //bodies+=PatternBody ('|' bodies+=PatternBody)* | 1532 | //ID |
| 763 | public Group getGroup_4_1() { return cGroup_4_1; } | 1533 | public RuleCall getNameIDTerminalRuleCall_3_0() { return cNameIDTerminalRuleCall_3_0; } |
| 764 | 1534 | ||
| 765 | //bodies+=PatternBody | 1535 | //("opposite" opposite=[NamedElement|QualifiedName])? |
| 766 | public Assignment getBodiesAssignment_4_1_0() { return cBodiesAssignment_4_1_0; } | 1536 | public Group getGroup_4() { return cGroup_4; } |
| 767 | 1537 | ||
| 768 | //PatternBody | 1538 | //"opposite" |
| 769 | public RuleCall getBodiesPatternBodyParserRuleCall_4_1_0_0() { return cBodiesPatternBodyParserRuleCall_4_1_0_0; } | 1539 | public Keyword getOppositeKeyword_4_0() { return cOppositeKeyword_4_0; } |
| 770 | 1540 | ||
| 771 | //('|' bodies+=PatternBody)* | 1541 | //opposite=[NamedElement|QualifiedName] |
| 772 | public Group getGroup_4_1_1() { return cGroup_4_1_1; } | 1542 | public Assignment getOppositeAssignment_4_1() { return cOppositeAssignment_4_1; } |
| 773 | 1543 | ||
| 774 | //'|' | 1544 | //[NamedElement|QualifiedName] |
| 775 | public Keyword getVerticalLineKeyword_4_1_1_0() { return cVerticalLineKeyword_4_1_1_0; } | 1545 | public CrossReference getOppositeNamedElementCrossReference_4_1_0() { return cOppositeNamedElementCrossReference_4_1_0; } |
| 776 | 1546 | ||
| 777 | //bodies+=PatternBody | 1547 | //QualifiedName |
| 778 | public Assignment getBodiesAssignment_4_1_1_1() { return cBodiesAssignment_4_1_1_1; } | 1548 | public RuleCall getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1() { return cOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1; } |
| 779 | 1549 | ||
| 780 | //PatternBody | 1550 | //";"? |
| 781 | public RuleCall getBodiesPatternBodyParserRuleCall_4_1_1_1_0() { return cBodiesPatternBodyParserRuleCall_4_1_1_1_0; } | 1551 | public Keyword getSemicolonKeyword_5() { return cSemicolonKeyword_5; } |
| 1552 | } | ||
| 1553 | public class MultiplicityElements extends AbstractParserRuleElementFinder { | ||
| 1554 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
| 1555 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 1556 | private final RuleCall cManyMultiplicityParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
| 1557 | private final RuleCall cExactMultiplicityParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
| 1558 | private final RuleCall cBoundedMultiplicityParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
| 782 | 1559 | ||
| 783 | //'.' | 1560 | //Multiplicity: |
| 784 | public Keyword getFullStopKeyword_5() { return cFullStopKeyword_5; } | 1561 | // ManyMultiplicity | ExactMultiplicity | BoundedMultiplicity; |
| 1562 | @Override public ParserRule getRule() { return rule; } | ||
| 1563 | |||
| 1564 | //ManyMultiplicity | ExactMultiplicity | BoundedMultiplicity | ||
| 1565 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1566 | |||
| 1567 | //ManyMultiplicity | ||
| 1568 | public RuleCall getManyMultiplicityParserRuleCall_0() { return cManyMultiplicityParserRuleCall_0; } | ||
| 1569 | |||
| 1570 | //ExactMultiplicity | ||
| 1571 | public RuleCall getExactMultiplicityParserRuleCall_1() { return cExactMultiplicityParserRuleCall_1; } | ||
| 1572 | |||
| 1573 | //BoundedMultiplicity | ||
| 1574 | public RuleCall getBoundedMultiplicityParserRuleCall_2() { return cBoundedMultiplicityParserRuleCall_2; } | ||
| 785 | } | 1575 | } |
| 786 | public class ParameterElements extends AbstractParserRuleElementFinder { | 1576 | public class ManyMultiplicityElements extends AbstractParserRuleElementFinder { |
| 787 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); | 1577 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ManyMultiplicity"); |
| 788 | private final Group cGroup = (Group)rule.eContents().get(1); | 1578 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 789 | private final Assignment cVariableAssignment_0 = (Assignment)cGroup.eContents().get(0); | 1579 | private final Action cManyMultiplicityAction_0 = (Action)cGroup.eContents().get(0); |
| 790 | private final RuleCall cVariableVariableParserRuleCall_0_0 = (RuleCall)cVariableAssignment_0.eContents().get(0); | 1580 | private final Keyword cLeftSquareBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| 791 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | 1581 | private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); |
| 792 | private final Keyword cColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); | ||
| 793 | private final Assignment cTypeAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
| 794 | private final RuleCall cTypeSymbolParserRuleCall_1_1_0 = (RuleCall)cTypeAssignment_1_1.eContents().get(0); | ||
| 795 | 1582 | ||
| 796 | //Parameter: | 1583 | //ManyMultiplicity: |
| 797 | // variable=Variable (':' type=Symbol)?; | 1584 | // {ManyMultiplicity} "[" "]"; |
| 798 | @Override public ParserRule getRule() { return rule; } | 1585 | @Override public ParserRule getRule() { return rule; } |
| 799 | 1586 | ||
| 800 | //variable=Variable (':' type=Symbol)? | 1587 | //{ManyMultiplicity} "[" "]" |
| 801 | public Group getGroup() { return cGroup; } | 1588 | public Group getGroup() { return cGroup; } |
| 802 | 1589 | ||
| 803 | //variable=Variable | 1590 | //{ManyMultiplicity} |
| 804 | public Assignment getVariableAssignment_0() { return cVariableAssignment_0; } | 1591 | public Action getManyMultiplicityAction_0() { return cManyMultiplicityAction_0; } |
| 805 | 1592 | ||
| 806 | //Variable | 1593 | //"[" |
| 807 | public RuleCall getVariableVariableParserRuleCall_0_0() { return cVariableVariableParserRuleCall_0_0; } | 1594 | public Keyword getLeftSquareBracketKeyword_1() { return cLeftSquareBracketKeyword_1; } |
| 808 | 1595 | ||
| 809 | //(':' type=Symbol)? | 1596 | //"]" |
| 810 | public Group getGroup_1() { return cGroup_1; } | 1597 | public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; } |
| 1598 | } | ||
| 1599 | public class ExactMultiplicityElements extends AbstractParserRuleElementFinder { | ||
| 1600 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExactMultiplicity"); | ||
| 1601 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 1602 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
| 1603 | private final Assignment cMultiplicityAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 1604 | private final RuleCall cMultiplicityUpperMultiplictyParserRuleCall_1_0 = (RuleCall)cMultiplicityAssignment_1.eContents().get(0); | ||
| 1605 | private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 811 | 1606 | ||
| 812 | //':' | 1607 | //ExactMultiplicity: |
| 813 | public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; } | 1608 | // "[" multiplicity=UpperMultiplicty "]"; |
| 1609 | @Override public ParserRule getRule() { return rule; } | ||
| 1610 | |||
| 1611 | //"[" multiplicity=UpperMultiplicty "]" | ||
| 1612 | public Group getGroup() { return cGroup; } | ||
| 814 | 1613 | ||
| 815 | //type=Symbol | 1614 | //"[" |
| 816 | public Assignment getTypeAssignment_1_1() { return cTypeAssignment_1_1; } | 1615 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } |
| 817 | 1616 | ||
| 818 | //Symbol | 1617 | //multiplicity=UpperMultiplicty |
| 819 | public RuleCall getTypeSymbolParserRuleCall_1_1_0() { return cTypeSymbolParserRuleCall_1_1_0; } | 1618 | public Assignment getMultiplicityAssignment_1() { return cMultiplicityAssignment_1; } |
| 1619 | |||
| 1620 | //UpperMultiplicty | ||
| 1621 | public RuleCall getMultiplicityUpperMultiplictyParserRuleCall_1_0() { return cMultiplicityUpperMultiplictyParserRuleCall_1_0; } | ||
| 1622 | |||
| 1623 | //"]" | ||
| 1624 | public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; } | ||
| 820 | } | 1625 | } |
| 821 | public class PatternBodyElements extends AbstractParserRuleElementFinder { | 1626 | public class BoundedMultiplicityElements extends AbstractParserRuleElementFinder { |
| 822 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); | 1627 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BoundedMultiplicity"); |
| 823 | private final Group cGroup = (Group)rule.eContents().get(1); | 1628 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 824 | private final Action cPatternBodyAction_0 = (Action)cGroup.eContents().get(0); | 1629 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 825 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | 1630 | private final Assignment cLowerBoundAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 826 | private final Keyword cTrueKeyword_1_0 = (Keyword)cAlternatives_1.eContents().get(0); | 1631 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0 = (RuleCall)cLowerBoundAssignment_1.eContents().get(0); |
| 827 | private final Assignment cConstraintsAssignment_1_1 = (Assignment)cAlternatives_1.eContents().get(1); | 1632 | private final Keyword cFullStopFullStopKeyword_2 = (Keyword)cGroup.eContents().get(2); |
| 828 | private final RuleCall cConstraintsConstraintParserRuleCall_1_1_0 = (RuleCall)cConstraintsAssignment_1_1.eContents().get(0); | 1633 | private final Assignment cUpperBoundAssignment_3 = (Assignment)cGroup.eContents().get(3); |
| 829 | 1634 | private final RuleCall cUpperBoundUpperMultiplictyParserRuleCall_3_0 = (RuleCall)cUpperBoundAssignment_3.eContents().get(0); | |
| 830 | //PatternBody: | 1635 | private final Keyword cRightSquareBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); |
| 831 | // {PatternBody} ('true' | constraints+=Constraint*); | 1636 | |
| 1637 | //BoundedMultiplicity: | ||
| 1638 | // "[" lowerBound=INT ".." upperBound=UpperMultiplicty "]"; | ||
| 832 | @Override public ParserRule getRule() { return rule; } | 1639 | @Override public ParserRule getRule() { return rule; } |
| 833 | 1640 | ||
| 834 | //{PatternBody} ('true' | constraints+=Constraint*) | 1641 | //"[" lowerBound=INT ".." upperBound=UpperMultiplicty "]" |
| 835 | public Group getGroup() { return cGroup; } | 1642 | public Group getGroup() { return cGroup; } |
| 836 | 1643 | ||
| 837 | //{PatternBody} | 1644 | //"[" |
| 838 | public Action getPatternBodyAction_0() { return cPatternBodyAction_0; } | 1645 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } |
| 839 | 1646 | ||
| 840 | //'true' | constraints+=Constraint* | 1647 | //lowerBound=INT |
| 841 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | 1648 | public Assignment getLowerBoundAssignment_1() { return cLowerBoundAssignment_1; } |
| 1649 | |||
| 1650 | //INT | ||
| 1651 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0() { return cLowerBoundINTTerminalRuleCall_1_0; } | ||
| 1652 | |||
| 1653 | //".." | ||
| 1654 | public Keyword getFullStopFullStopKeyword_2() { return cFullStopFullStopKeyword_2; } | ||
| 842 | 1655 | ||
| 843 | //'true' | 1656 | //upperBound=UpperMultiplicty |
| 844 | public Keyword getTrueKeyword_1_0() { return cTrueKeyword_1_0; } | 1657 | public Assignment getUpperBoundAssignment_3() { return cUpperBoundAssignment_3; } |
| 845 | 1658 | ||
| 846 | //constraints+=Constraint* | 1659 | //UpperMultiplicty |
| 847 | public Assignment getConstraintsAssignment_1_1() { return cConstraintsAssignment_1_1; } | 1660 | public RuleCall getUpperBoundUpperMultiplictyParserRuleCall_3_0() { return cUpperBoundUpperMultiplictyParserRuleCall_3_0; } |
| 848 | 1661 | ||
| 849 | //Constraint | 1662 | //"]" |
| 850 | public RuleCall getConstraintsConstraintParserRuleCall_1_1_0() { return cConstraintsConstraintParserRuleCall_1_1_0; } | 1663 | public Keyword getRightSquareBracketKeyword_4() { return cRightSquareBracketKeyword_4; } |
| 851 | } | 1664 | } |
| 852 | public class PolarityElements extends AbstractParserRuleElementFinder { | 1665 | public class ScopeDefinitionElements extends AbstractParserRuleElementFinder { |
| 853 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); | 1666 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ScopeDefinition"); |
| 854 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1667 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 855 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); | 1668 | private final RuleCall cExactScopeDefinitionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 856 | private final Action cPositiveAction_0_0 = (Action)cGroup_0.eContents().get(0); | 1669 | private final RuleCall cBoundedScopeDefinitionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 857 | private final Keyword cPlusSignKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); | 1670 | private final RuleCall cLowerBoundedScopeDefinitionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); |
| 858 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | ||
| 859 | private final Action cNegativeAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
| 860 | private final Keyword cHyphenMinusKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); | ||
| 861 | 1671 | ||
| 862 | //Polarity: | 1672 | //ScopeDefinition: |
| 863 | // {Positive} '+' | {Negative} '-'; | 1673 | // ExactScopeDefinition | BoundedScopeDefinition | LowerBoundedScopeDefinition; |
| 864 | @Override public ParserRule getRule() { return rule; } | 1674 | @Override public ParserRule getRule() { return rule; } |
| 865 | 1675 | ||
| 866 | //{Positive} '+' | {Negative} '-' | 1676 | //ExactScopeDefinition | BoundedScopeDefinition | LowerBoundedScopeDefinition |
| 867 | public Alternatives getAlternatives() { return cAlternatives; } | 1677 | public Alternatives getAlternatives() { return cAlternatives; } |
| 868 | 1678 | ||
| 869 | //{Positive} '+' | 1679 | //ExactScopeDefinition |
| 870 | public Group getGroup_0() { return cGroup_0; } | 1680 | public RuleCall getExactScopeDefinitionParserRuleCall_0() { return cExactScopeDefinitionParserRuleCall_0; } |
| 1681 | |||
| 1682 | //BoundedScopeDefinition | ||
| 1683 | public RuleCall getBoundedScopeDefinitionParserRuleCall_1() { return cBoundedScopeDefinitionParserRuleCall_1; } | ||
| 1684 | |||
| 1685 | //LowerBoundedScopeDefinition | ||
| 1686 | public RuleCall getLowerBoundedScopeDefinitionParserRuleCall_2() { return cLowerBoundedScopeDefinitionParserRuleCall_2; } | ||
| 1687 | } | ||
| 1688 | public class ExactScopeDefinitionElements extends AbstractParserRuleElementFinder { | ||
| 1689 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExactScopeDefinition"); | ||
| 1690 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
| 1691 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
| 1692 | private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
| 1693 | private final CrossReference cTypeNamedElementCrossReference_1_0 = (CrossReference)cTypeAssignment_1.eContents().get(0); | ||
| 1694 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_0.eContents().get(1); | ||
| 1695 | private final Keyword cEqualsSignEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 1696 | private final Assignment cExactScopeAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 1697 | private final RuleCall cExactScopeINTTerminalRuleCall_3_0 = (RuleCall)cExactScopeAssignment_3.eContents().get(0); | ||
| 1698 | |||
| 1699 | //ExactScopeDefinition: | ||
| 1700 | // "scope" type=[NamedElement|QualifiedName] "==" exactScope=INT; | ||
| 1701 | @Override public ParserRule getRule() { return rule; } | ||
| 871 | 1702 | ||
| 872 | //{Positive} | 1703 | //"scope" type=[NamedElement|QualifiedName] "==" exactScope=INT |
| 873 | public Action getPositiveAction_0_0() { return cPositiveAction_0_0; } | 1704 | public Group getGroup() { return cGroup; } |
| 874 | 1705 | ||
| 875 | //'+' | 1706 | //"scope" |
| 876 | public Keyword getPlusSignKeyword_0_1() { return cPlusSignKeyword_0_1; } | 1707 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } |
| 877 | 1708 | ||
| 878 | //{Negative} '-' | 1709 | //type=[NamedElement|QualifiedName] |
| 879 | public Group getGroup_1() { return cGroup_1; } | 1710 | public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } |
| 880 | 1711 | ||
| 881 | //{Negative} | 1712 | //[NamedElement|QualifiedName] |
| 882 | public Action getNegativeAction_1_0() { return cNegativeAction_1_0; } | 1713 | public CrossReference getTypeNamedElementCrossReference_1_0() { return cTypeNamedElementCrossReference_1_0; } |
| 883 | 1714 | ||
| 884 | //'-' | 1715 | //QualifiedName |
| 885 | public Keyword getHyphenMinusKeyword_1_1() { return cHyphenMinusKeyword_1_1; } | 1716 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_0_1; } |
| 1717 | |||
| 1718 | //"==" | ||
| 1719 | public Keyword getEqualsSignEqualsSignKeyword_2() { return cEqualsSignEqualsSignKeyword_2; } | ||
| 1720 | |||
| 1721 | //exactScope=INT | ||
| 1722 | public Assignment getExactScopeAssignment_3() { return cExactScopeAssignment_3; } | ||
| 1723 | |||
| 1724 | //INT | ||
| 1725 | public RuleCall getExactScopeINTTerminalRuleCall_3_0() { return cExactScopeINTTerminalRuleCall_3_0; } | ||
| 886 | } | 1726 | } |
| 887 | public class ConstraintElements extends AbstractParserRuleElementFinder { | 1727 | public class BoundedScopeDefinitionElements extends AbstractParserRuleElementFinder { |
| 888 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); | 1728 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BoundedScopeDefinition"); |
| 889 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1729 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 890 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); | 1730 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 891 | private final Assignment cPolarityAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0); | 1731 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); |
| 892 | private final RuleCall cPolarityPolarityParserRuleCall_0_0_0 = (RuleCall)cPolarityAssignment_0_0.eContents().get(0); | 1732 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); |
| 893 | private final Assignment cSymbolAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); | 1733 | private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0); |
| 894 | private final RuleCall cSymbolModelSymbolParserRuleCall_0_1_0 = (RuleCall)cSymbolAssignment_0_1.eContents().get(0); | 1734 | private final Assignment cLowerBoundAssignment_1_0_0_0 = (Assignment)cGroup_1_0_0.eContents().get(0); |
| 895 | private final Group cGroup_0_2 = (Group)cGroup_0.eContents().get(2); | 1735 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0_0_0_0 = (RuleCall)cLowerBoundAssignment_1_0_0_0.eContents().get(0); |
| 896 | private final Keyword cLeftParenthesisKeyword_0_2_0 = (Keyword)cGroup_0_2.eContents().get(0); | 1736 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_0_1 = (Keyword)cGroup_1_0_0.eContents().get(1); |
| 897 | private final Assignment cParamsAssignment_0_2_1 = (Assignment)cGroup_0_2.eContents().get(1); | 1737 | private final Assignment cTypeAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1); |
| 898 | private final RuleCall cParamsLiteralParserRuleCall_0_2_1_0 = (RuleCall)cParamsAssignment_0_2_1.eContents().get(0); | 1738 | private final CrossReference cTypeNamedElementCrossReference_1_0_1_0 = (CrossReference)cTypeAssignment_1_0_1.eContents().get(0); |
| 899 | private final Group cGroup_0_2_2 = (Group)cGroup_0_2.eContents().get(2); | 1739 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_0_1_0.eContents().get(1); |
| 900 | private final Keyword cCommaKeyword_0_2_2_0 = (Keyword)cGroup_0_2_2.eContents().get(0); | 1740 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_2 = (Keyword)cGroup_1_0.eContents().get(2); |
| 901 | private final Assignment cParamsAssignment_0_2_2_1 = (Assignment)cGroup_0_2_2.eContents().get(1); | 1741 | private final Assignment cUpperBoundAssignment_1_0_3 = (Assignment)cGroup_1_0.eContents().get(3); |
| 902 | private final RuleCall cParamsLiteralParserRuleCall_0_2_2_1_0 = (RuleCall)cParamsAssignment_0_2_2_1.eContents().get(0); | 1742 | private final RuleCall cUpperBoundINTTerminalRuleCall_1_0_3_0 = (RuleCall)cUpperBoundAssignment_1_0_3.eContents().get(0); |
| 903 | private final Keyword cRightParenthesisKeyword_0_2_3 = (Keyword)cGroup_0_2.eContents().get(3); | 1743 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); |
| 904 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | 1744 | private final Assignment cUpperBoundAssignment_1_1_0 = (Assignment)cGroup_1_1.eContents().get(0); |
| 905 | private final Assignment cClosureTypeAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0); | 1745 | private final RuleCall cUpperBoundINTTerminalRuleCall_1_1_0_0 = (RuleCall)cUpperBoundAssignment_1_1_0.eContents().get(0); |
| 906 | private final RuleCall cClosureTypeClosureTypeParserRuleCall_1_0_0 = (RuleCall)cClosureTypeAssignment_1_0.eContents().get(0); | 1746 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); |
| 907 | private final Keyword cLeftParenthesisKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); | 1747 | private final Assignment cTypeAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); |
| 908 | private final Assignment cParamsAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | 1748 | private final CrossReference cTypeNamedElementCrossReference_1_1_2_0 = (CrossReference)cTypeAssignment_1_1_2.eContents().get(0); |
| 909 | private final RuleCall cParamsLiteralParserRuleCall_1_2_0 = (RuleCall)cParamsAssignment_1_2.eContents().get(0); | 1749 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_1_2_0.eContents().get(1); |
| 910 | private final Group cGroup_1_3 = (Group)cGroup_1.eContents().get(3); | 1750 | private final Group cGroup_1_1_3 = (Group)cGroup_1_1.eContents().get(3); |
| 911 | private final Keyword cCommaKeyword_1_3_0 = (Keyword)cGroup_1_3.eContents().get(0); | 1751 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_3_0 = (Keyword)cGroup_1_1_3.eContents().get(0); |
| 912 | private final Assignment cParamsAssignment_1_3_1 = (Assignment)cGroup_1_3.eContents().get(1); | 1752 | private final Assignment cLowerBoundAssignment_1_1_3_1 = (Assignment)cGroup_1_1_3.eContents().get(1); |
| 913 | private final RuleCall cParamsLiteralParserRuleCall_1_3_1_0 = (RuleCall)cParamsAssignment_1_3_1.eContents().get(0); | 1753 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_1_3_1_0 = (RuleCall)cLowerBoundAssignment_1_1_3_1.eContents().get(0); |
| 914 | private final Keyword cRightParenthesisKeyword_1_4 = (Keyword)cGroup_1.eContents().get(4); | 1754 | |
| 915 | 1755 | //BoundedScopeDefinition: | |
| 916 | //Constraint: | 1756 | // "scope" ((lowerBound=INT "<=")? type=[NamedElement|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" |
| 917 | // polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal? (',' params+=Literal)* ')')? | closureType=ClosureType | 1757 | // type=[NamedElement|QualifiedName] (">=" lowerBound=INT)?); |
| 918 | // '(' params+=Literal? (',' params+=Literal)* ')'; | ||
| 919 | @Override public ParserRule getRule() { return rule; } | 1758 | @Override public ParserRule getRule() { return rule; } |
| 920 | 1759 | ||
| 921 | //polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal? (',' params+=Literal)* ')')? | closureType=ClosureType '(' | 1760 | //"scope" ((lowerBound=INT "<=")? type=[NamedElement|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" |
| 922 | //params+=Literal? (',' params+=Literal)* ')' | 1761 | //type=[NamedElement|QualifiedName] (">=" lowerBound=INT)?) |
| 923 | public Alternatives getAlternatives() { return cAlternatives; } | 1762 | public Group getGroup() { return cGroup; } |
| 924 | |||
| 925 | //polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal? (',' params+=Literal)* ')')? | ||
| 926 | public Group getGroup_0() { return cGroup_0; } | ||
| 927 | 1763 | ||
| 928 | //polarity=Polarity? | 1764 | //"scope" |
| 929 | public Assignment getPolarityAssignment_0_0() { return cPolarityAssignment_0_0; } | 1765 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } |
| 930 | 1766 | ||
| 931 | //Polarity | 1767 | //((lowerBound=INT "<=")? type=[NamedElement|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" |
| 932 | public RuleCall getPolarityPolarityParserRuleCall_0_0_0() { return cPolarityPolarityParserRuleCall_0_0_0; } | 1768 | //type=[NamedElement|QualifiedName] (">=" lowerBound=INT)?) |
| 1769 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
| 933 | 1770 | ||
| 934 | //symbol=ModelSymbol | 1771 | //(lowerBound=INT "<=")? type=[NamedElement|QualifiedName] "<=" upperBound=INT |
| 935 | public Assignment getSymbolAssignment_0_1() { return cSymbolAssignment_0_1; } | 1772 | public Group getGroup_1_0() { return cGroup_1_0; } |
| 936 | 1773 | ||
| 937 | //ModelSymbol | 1774 | //(lowerBound=INT "<=")? |
| 938 | public RuleCall getSymbolModelSymbolParserRuleCall_0_1_0() { return cSymbolModelSymbolParserRuleCall_0_1_0; } | 1775 | public Group getGroup_1_0_0() { return cGroup_1_0_0; } |
| 939 | 1776 | ||
| 940 | //('(' params+=Literal? (',' params+=Literal)* ')')? | 1777 | //lowerBound=INT |
| 941 | public Group getGroup_0_2() { return cGroup_0_2; } | 1778 | public Assignment getLowerBoundAssignment_1_0_0_0() { return cLowerBoundAssignment_1_0_0_0; } |
| 942 | 1779 | ||
| 943 | //'(' | 1780 | //INT |
| 944 | public Keyword getLeftParenthesisKeyword_0_2_0() { return cLeftParenthesisKeyword_0_2_0; } | 1781 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0_0_0_0() { return cLowerBoundINTTerminalRuleCall_1_0_0_0_0; } |
| 945 | 1782 | ||
| 946 | //params+=Literal? | 1783 | //"<=" |
| 947 | public Assignment getParamsAssignment_0_2_1() { return cParamsAssignment_0_2_1; } | 1784 | public Keyword getLessThanSignEqualsSignKeyword_1_0_0_1() { return cLessThanSignEqualsSignKeyword_1_0_0_1; } |
| 948 | 1785 | ||
| 949 | //Literal | 1786 | //type=[NamedElement|QualifiedName] |
| 950 | public RuleCall getParamsLiteralParserRuleCall_0_2_1_0() { return cParamsLiteralParserRuleCall_0_2_1_0; } | 1787 | public Assignment getTypeAssignment_1_0_1() { return cTypeAssignment_1_0_1; } |
| 951 | 1788 | ||
| 952 | //(',' params+=Literal)* | 1789 | //[NamedElement|QualifiedName] |
| 953 | public Group getGroup_0_2_2() { return cGroup_0_2_2; } | 1790 | public CrossReference getTypeNamedElementCrossReference_1_0_1_0() { return cTypeNamedElementCrossReference_1_0_1_0; } |
| 954 | 1791 | ||
| 955 | //',' | 1792 | //QualifiedName |
| 956 | public Keyword getCommaKeyword_0_2_2_0() { return cCommaKeyword_0_2_2_0; } | 1793 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1; } |
| 957 | 1794 | ||
| 958 | //params+=Literal | 1795 | //"<=" |
| 959 | public Assignment getParamsAssignment_0_2_2_1() { return cParamsAssignment_0_2_2_1; } | 1796 | public Keyword getLessThanSignEqualsSignKeyword_1_0_2() { return cLessThanSignEqualsSignKeyword_1_0_2; } |
| 960 | 1797 | ||
| 961 | //Literal | 1798 | //upperBound=INT |
| 962 | public RuleCall getParamsLiteralParserRuleCall_0_2_2_1_0() { return cParamsLiteralParserRuleCall_0_2_2_1_0; } | 1799 | public Assignment getUpperBoundAssignment_1_0_3() { return cUpperBoundAssignment_1_0_3; } |
| 963 | 1800 | ||
| 964 | //')' | 1801 | //INT |
| 965 | public Keyword getRightParenthesisKeyword_0_2_3() { return cRightParenthesisKeyword_0_2_3; } | 1802 | public RuleCall getUpperBoundINTTerminalRuleCall_1_0_3_0() { return cUpperBoundINTTerminalRuleCall_1_0_3_0; } |
| 966 | 1803 | ||
| 967 | //closureType=ClosureType '(' params+=Literal? (',' params+=Literal)* ')' | 1804 | //upperBound=INT ">=" type=[NamedElement|QualifiedName] (">=" lowerBound=INT)? |
| 968 | public Group getGroup_1() { return cGroup_1; } | 1805 | public Group getGroup_1_1() { return cGroup_1_1; } |
| 969 | 1806 | ||
| 970 | //closureType=ClosureType | 1807 | //upperBound=INT |
| 971 | public Assignment getClosureTypeAssignment_1_0() { return cClosureTypeAssignment_1_0; } | 1808 | public Assignment getUpperBoundAssignment_1_1_0() { return cUpperBoundAssignment_1_1_0; } |
| 972 | 1809 | ||
| 973 | //ClosureType | 1810 | //INT |
| 974 | public RuleCall getClosureTypeClosureTypeParserRuleCall_1_0_0() { return cClosureTypeClosureTypeParserRuleCall_1_0_0; } | 1811 | public RuleCall getUpperBoundINTTerminalRuleCall_1_1_0_0() { return cUpperBoundINTTerminalRuleCall_1_1_0_0; } |
| 975 | 1812 | ||
| 976 | //'(' | 1813 | //">=" |
| 977 | public Keyword getLeftParenthesisKeyword_1_1() { return cLeftParenthesisKeyword_1_1; } | 1814 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_1() { return cGreaterThanSignEqualsSignKeyword_1_1_1; } |
| 978 | 1815 | ||
| 979 | //params+=Literal? | 1816 | //type=[NamedElement|QualifiedName] |
| 980 | public Assignment getParamsAssignment_1_2() { return cParamsAssignment_1_2; } | 1817 | public Assignment getTypeAssignment_1_1_2() { return cTypeAssignment_1_1_2; } |
| 981 | 1818 | ||
| 982 | //Literal | 1819 | //[NamedElement|QualifiedName] |
| 983 | public RuleCall getParamsLiteralParserRuleCall_1_2_0() { return cParamsLiteralParserRuleCall_1_2_0; } | 1820 | public CrossReference getTypeNamedElementCrossReference_1_1_2_0() { return cTypeNamedElementCrossReference_1_1_2_0; } |
| 984 | 1821 | ||
| 985 | //(',' params+=Literal)* | 1822 | //QualifiedName |
| 986 | public Group getGroup_1_3() { return cGroup_1_3; } | 1823 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1; } |
| 987 | 1824 | ||
| 988 | //',' | 1825 | //(">=" lowerBound=INT)? |
| 989 | public Keyword getCommaKeyword_1_3_0() { return cCommaKeyword_1_3_0; } | 1826 | public Group getGroup_1_1_3() { return cGroup_1_1_3; } |
| 990 | 1827 | ||
| 991 | //params+=Literal | 1828 | //">=" |
| 992 | public Assignment getParamsAssignment_1_3_1() { return cParamsAssignment_1_3_1; } | 1829 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_3_0() { return cGreaterThanSignEqualsSignKeyword_1_1_3_0; } |
| 993 | 1830 | ||
| 994 | //Literal | 1831 | //lowerBound=INT |
| 995 | public RuleCall getParamsLiteralParserRuleCall_1_3_1_0() { return cParamsLiteralParserRuleCall_1_3_1_0; } | 1832 | public Assignment getLowerBoundAssignment_1_1_3_1() { return cLowerBoundAssignment_1_1_3_1; } |
| 996 | 1833 | ||
| 997 | //')' | 1834 | //INT |
| 998 | public Keyword getRightParenthesisKeyword_1_4() { return cRightParenthesisKeyword_1_4; } | 1835 | public RuleCall getLowerBoundINTTerminalRuleCall_1_1_3_1_0() { return cLowerBoundINTTerminalRuleCall_1_1_3_1_0; } |
| 999 | } | 1836 | } |
| 1000 | public class ClosureTypeElements extends AbstractParserRuleElementFinder { | 1837 | public class LowerBoundedScopeDefinitionElements extends AbstractParserRuleElementFinder { |
| 1001 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); | 1838 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LowerBoundedScopeDefinition"); |
| 1002 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1839 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 1003 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); | 1840 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); |
| 1004 | private final Action cReflexiveClosureAction_0_0 = (Action)cGroup_0.eContents().get(0); | 1841 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); |
| 1005 | private final Keyword cAsteriskKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); | 1842 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); |
| 1006 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | 1843 | private final Assignment cLowerBoundAssignment_1_0_0 = (Assignment)cGroup_1_0.eContents().get(0); |
| 1007 | private final Action cIrreflexiveClosureAction_1_0 = (Action)cGroup_1.eContents().get(0); | 1844 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0_0_0 = (RuleCall)cLowerBoundAssignment_1_0_0.eContents().get(0); |
| 1008 | private final Keyword cPlusSignKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); | 1845 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_1 = (Keyword)cGroup_1_0.eContents().get(1); |
| 1009 | 1846 | private final Assignment cTypeAssignment_1_0_2 = (Assignment)cGroup_1_0.eContents().get(2); | |
| 1010 | //ClosureType: | 1847 | private final CrossReference cTypeNamedElementCrossReference_1_0_2_0 = (CrossReference)cTypeAssignment_1_0_2.eContents().get(0); |
| 1011 | // {ReflexiveClosure} '*' | {IrreflexiveClosure} '+'; | 1848 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_0_2_0.eContents().get(1); |
| 1849 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
| 1850 | private final Assignment cTypeAssignment_1_1_0 = (Assignment)cGroup_1_1.eContents().get(0); | ||
| 1851 | private final CrossReference cTypeNamedElementCrossReference_1_1_0_0 = (CrossReference)cTypeAssignment_1_1_0.eContents().get(0); | ||
| 1852 | private final RuleCall cTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1 = (RuleCall)cTypeNamedElementCrossReference_1_1_0_0.eContents().get(1); | ||
| 1853 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
| 1854 | private final Assignment cLowerBoundAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
| 1855 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_1_2_0 = (RuleCall)cLowerBoundAssignment_1_1_2.eContents().get(0); | ||
| 1856 | |||
| 1857 | //LowerBoundedScopeDefinition: | ||
| 1858 | // "scope" (lowerBound=INT "<=" type=[NamedElement|QualifiedName] | type=[NamedElement|QualifiedName] ">=" | ||
| 1859 | // lowerBound=INT); | ||
| 1012 | @Override public ParserRule getRule() { return rule; } | 1860 | @Override public ParserRule getRule() { return rule; } |
| 1013 | 1861 | ||
| 1014 | //{ReflexiveClosure} '*' | {IrreflexiveClosure} '+' | 1862 | //"scope" (lowerBound=INT "<=" type=[NamedElement|QualifiedName] | type=[NamedElement|QualifiedName] ">=" lowerBound=INT) |
| 1015 | public Alternatives getAlternatives() { return cAlternatives; } | 1863 | public Group getGroup() { return cGroup; } |
| 1016 | 1864 | ||
| 1017 | //{ReflexiveClosure} '*' | 1865 | //"scope" |
| 1018 | public Group getGroup_0() { return cGroup_0; } | 1866 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } |
| 1019 | 1867 | ||
| 1020 | //{ReflexiveClosure} | 1868 | //(lowerBound=INT "<=" type=[NamedElement|QualifiedName] | type=[NamedElement|QualifiedName] ">=" lowerBound=INT) |
| 1021 | public Action getReflexiveClosureAction_0_0() { return cReflexiveClosureAction_0_0; } | 1869 | public Alternatives getAlternatives_1() { return cAlternatives_1; } |
| 1022 | 1870 | ||
| 1023 | //'*' | 1871 | //lowerBound=INT "<=" type=[NamedElement|QualifiedName] |
| 1024 | public Keyword getAsteriskKeyword_0_1() { return cAsteriskKeyword_0_1; } | 1872 | public Group getGroup_1_0() { return cGroup_1_0; } |
| 1025 | 1873 | ||
| 1026 | //{IrreflexiveClosure} '+' | 1874 | //lowerBound=INT |
| 1027 | public Group getGroup_1() { return cGroup_1; } | 1875 | public Assignment getLowerBoundAssignment_1_0_0() { return cLowerBoundAssignment_1_0_0; } |
| 1028 | 1876 | ||
| 1029 | //{IrreflexiveClosure} | 1877 | //INT |
| 1030 | public Action getIrreflexiveClosureAction_1_0() { return cIrreflexiveClosureAction_1_0; } | 1878 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0_0_0() { return cLowerBoundINTTerminalRuleCall_1_0_0_0; } |
| 1031 | 1879 | ||
| 1032 | //'+' | 1880 | //"<=" |
| 1033 | public Keyword getPlusSignKeyword_1_1() { return cPlusSignKeyword_1_1; } | 1881 | public Keyword getLessThanSignEqualsSignKeyword_1_0_1() { return cLessThanSignEqualsSignKeyword_1_0_1; } |
| 1034 | } | ||
| 1035 | public class LiteralElements extends AbstractParserRuleElementFinder { | ||
| 1036 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
| 1037 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 1038 | private final RuleCall cVariableParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
| 1039 | private final RuleCall cDataObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
| 1040 | private final RuleCall cNamedObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
| 1041 | 1882 | ||
| 1042 | //Literal: | 1883 | //type=[NamedElement|QualifiedName] |
| 1043 | // Variable | DataObject | NamedObject; | 1884 | public Assignment getTypeAssignment_1_0_2() { return cTypeAssignment_1_0_2; } |
| 1044 | @Override public ParserRule getRule() { return rule; } | ||
| 1045 | 1885 | ||
| 1046 | //Variable | DataObject | NamedObject | 1886 | //[NamedElement|QualifiedName] |
| 1047 | public Alternatives getAlternatives() { return cAlternatives; } | 1887 | public CrossReference getTypeNamedElementCrossReference_1_0_2_0() { return cTypeNamedElementCrossReference_1_0_2_0; } |
| 1048 | 1888 | ||
| 1049 | //Variable | 1889 | //QualifiedName |
| 1050 | public RuleCall getVariableParserRuleCall_0() { return cVariableParserRuleCall_0; } | 1890 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1; } |
| 1051 | 1891 | ||
| 1052 | //DataObject | 1892 | //type=[NamedElement|QualifiedName] ">=" lowerBound=INT |
| 1053 | public RuleCall getDataObjectParserRuleCall_1() { return cDataObjectParserRuleCall_1; } | 1893 | public Group getGroup_1_1() { return cGroup_1_1; } |
| 1054 | 1894 | ||
| 1055 | //NamedObject | 1895 | //type=[NamedElement|QualifiedName] |
| 1056 | public RuleCall getNamedObjectParserRuleCall_2() { return cNamedObjectParserRuleCall_2; } | 1896 | public Assignment getTypeAssignment_1_1_0() { return cTypeAssignment_1_1_0; } |
| 1057 | } | ||
| 1058 | public class VariableElements extends AbstractParserRuleElementFinder { | ||
| 1059 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); | ||
| 1060 | private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); | ||
| 1061 | private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); | ||
| 1062 | 1897 | ||
| 1063 | //Variable: | 1898 | //[NamedElement|QualifiedName] |
| 1064 | // name=ID; | 1899 | public CrossReference getTypeNamedElementCrossReference_1_1_0_0() { return cTypeNamedElementCrossReference_1_1_0_0; } |
| 1065 | @Override public ParserRule getRule() { return rule; } | ||
| 1066 | 1900 | ||
| 1067 | //name=ID | 1901 | //QualifiedName |
| 1068 | public Assignment getNameAssignment() { return cNameAssignment; } | 1902 | public RuleCall getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1() { return cTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1; } |
| 1069 | 1903 | ||
| 1070 | //ID | 1904 | //">=" |
| 1071 | public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } | 1905 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_1() { return cGreaterThanSignEqualsSignKeyword_1_1_1; } |
| 1906 | |||
| 1907 | //lowerBound=INT | ||
| 1908 | public Assignment getLowerBoundAssignment_1_1_2() { return cLowerBoundAssignment_1_1_2; } | ||
| 1909 | |||
| 1910 | //INT | ||
| 1911 | public RuleCall getLowerBoundINTTerminalRuleCall_1_1_2_0() { return cLowerBoundINTTerminalRuleCall_1_1_2_0; } | ||
| 1072 | } | 1912 | } |
| 1073 | public class AllInstancesElements extends AbstractParserRuleElementFinder { | 1913 | public class ObjectiveDefinitionElements extends AbstractParserRuleElementFinder { |
| 1074 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllInstances"); | 1914 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveDefinition"); |
| 1075 | private final Group cGroup = (Group)rule.eContents().get(1); | 1915 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 1076 | private final Keyword cColonKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1916 | private final Assignment cKindAssignment_0 = (Assignment)cGroup.eContents().get(0); |
| 1077 | private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); | 1917 | private final RuleCall cKindObjectiveKindEnumRuleCall_0_0 = (RuleCall)cKindAssignment_0.eContents().get(0); |
| 1078 | private final RuleCall cSymbolSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); | 1918 | private final Assignment cObjectiveAssignment_1 = (Assignment)cGroup.eContents().get(1); |
| 1079 | 1919 | private final RuleCall cObjectiveExpressionParserRuleCall_1_0 = (RuleCall)cObjectiveAssignment_1.eContents().get(0); | |
| 1080 | ///////////////////// | 1920 | |
| 1081 | //// Complex Interpretation grammar | 1921 | //ObjectiveDefinition: |
| 1082 | ///////////////////// | 1922 | // kind=ObjectiveKind objective=Expression; |
| 1083 | //AllInstances: | ||
| 1084 | // ':' symbol=Symbol; | ||
| 1085 | @Override public ParserRule getRule() { return rule; } | 1923 | @Override public ParserRule getRule() { return rule; } |
| 1086 | 1924 | ||
| 1087 | //':' symbol=Symbol | 1925 | //kind=ObjectiveKind objective=Expression |
| 1088 | public Group getGroup() { return cGroup; } | 1926 | public Group getGroup() { return cGroup; } |
| 1089 | 1927 | ||
| 1090 | //':' | 1928 | //kind=ObjectiveKind |
| 1091 | public Keyword getColonKeyword_0() { return cColonKeyword_0; } | 1929 | public Assignment getKindAssignment_0() { return cKindAssignment_0; } |
| 1930 | |||
| 1931 | //ObjectiveKind | ||
| 1932 | public RuleCall getKindObjectiveKindEnumRuleCall_0_0() { return cKindObjectiveKindEnumRuleCall_0_0; } | ||
| 1092 | 1933 | ||
| 1093 | //symbol=Symbol | 1934 | //objective=Expression |
| 1094 | public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } | 1935 | public Assignment getObjectiveAssignment_1() { return cObjectiveAssignment_1; } |
| 1095 | 1936 | ||
| 1096 | //Symbol | 1937 | //Expression |
| 1097 | public RuleCall getSymbolSymbolParserRuleCall_1_0() { return cSymbolSymbolParserRuleCall_1_0; } | 1938 | public RuleCall getObjectiveExpressionParserRuleCall_1_0() { return cObjectiveExpressionParserRuleCall_1_0; } |
| 1098 | } | 1939 | } |
| 1099 | public class AllObjectsElements extends AbstractParserRuleElementFinder { | 1940 | public class UpperMultiplictyElements extends AbstractParserRuleElementFinder { |
| 1100 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllObjects"); | 1941 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); |
| 1101 | private final Group cGroup = (Group)rule.eContents().get(1); | 1942 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 1102 | private final Action cAllObjectsAction_0 = (Action)cGroup.eContents().get(0); | 1943 | private final RuleCall cINTTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
| 1103 | private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); | 1944 | private final Keyword cAsteriskKeyword_1 = (Keyword)cAlternatives.eContents().get(1); |
| 1104 | 1945 | ||
| 1105 | //AllObjects: | 1946 | //UpperMultiplicty ecore::EInt: |
| 1106 | // {AllObjects} '*'; | 1947 | // INT | "*"; |
| 1107 | @Override public ParserRule getRule() { return rule; } | 1948 | @Override public ParserRule getRule() { return rule; } |
| 1108 | 1949 | ||
| 1109 | //{AllObjects} '*' | 1950 | //INT | "*" |
| 1110 | public Group getGroup() { return cGroup; } | 1951 | public Alternatives getAlternatives() { return cAlternatives; } |
| 1111 | 1952 | ||
| 1112 | //{AllObjects} | 1953 | //INT |
| 1113 | public Action getAllObjectsAction_0() { return cAllObjectsAction_0; } | 1954 | public RuleCall getINTTerminalRuleCall_0() { return cINTTerminalRuleCall_0; } |
| 1114 | 1955 | ||
| 1115 | //'*' | 1956 | //"*" |
| 1116 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } | 1957 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } |
| 1117 | } | 1958 | } |
| 1118 | public class DefaultInterpretationElements extends AbstractParserRuleElementFinder { | 1959 | public class RealElements extends AbstractParserRuleElementFinder { |
| 1119 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DefaultInterpretation"); | 1960 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Real"); |
| 1120 | private final Group cGroup = (Group)rule.eContents().get(1); | 1961 | private final Group cGroup = (Group)rule.eContents().get(1); |
| 1121 | private final Keyword cDefaultKeyword_0 = (Keyword)cGroup.eContents().get(0); | 1962 | private final RuleCall cINTTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0); |
| 1122 | private final Assignment cInterpretationAssignment_1 = (Assignment)cGroup.eContents().get(1); | 1963 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); |
| 1123 | private final RuleCall cInterpretationBasicInterpretationParserRuleCall_1_0 = (RuleCall)cInterpretationAssignment_1.eContents().get(0); | 1964 | private final Keyword cFullStopKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); |
| 1124 | 1965 | private final RuleCall cINTTerminalRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1); | |
| 1125 | ///////////////////// | 1966 | |
| 1126 | //// Defaul Interpretation grammar | 1967 | //Real ecore::EBigDecimal hidden(): |
| 1127 | ///////////////////// | 1968 | // INT ("." INT)?; |
| 1128 | //DefaultInterpretation: | ||
| 1129 | // 'default' interpretation=BasicInterpretation; | ||
| 1130 | @Override public ParserRule getRule() { return rule; } | 1969 | @Override public ParserRule getRule() { return rule; } |
| 1131 | 1970 | ||
| 1132 | //'default' interpretation=BasicInterpretation | 1971 | //INT ("." INT)? |
| 1133 | public Group getGroup() { return cGroup; } | 1972 | public Group getGroup() { return cGroup; } |
| 1134 | 1973 | ||
| 1135 | //'default' | 1974 | //INT |
| 1136 | public Keyword getDefaultKeyword_0() { return cDefaultKeyword_0; } | 1975 | public RuleCall getINTTerminalRuleCall_0() { return cINTTerminalRuleCall_0; } |
| 1137 | 1976 | ||
| 1138 | //interpretation=BasicInterpretation | 1977 | //("." INT)? |
| 1139 | public Assignment getInterpretationAssignment_1() { return cInterpretationAssignment_1; } | 1978 | public Group getGroup_1() { return cGroup_1; } |
| 1979 | |||
| 1980 | //"." | ||
| 1981 | public Keyword getFullStopKeyword_1_0() { return cFullStopKeyword_1_0; } | ||
| 1140 | 1982 | ||
| 1141 | //BasicInterpretation | 1983 | //INT |
| 1142 | public RuleCall getInterpretationBasicInterpretationParserRuleCall_1_0() { return cInterpretationBasicInterpretationParserRuleCall_1_0; } | 1984 | public RuleCall getINTTerminalRuleCall_1_1() { return cINTTerminalRuleCall_1_1; } |
| 1143 | } | 1985 | } |
| 1144 | public class CDInterpretationElements extends AbstractParserRuleElementFinder { | 1986 | public class QualifiedNameElements extends AbstractParserRuleElementFinder { |
| 1145 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.CDInterpretation"); | 1987 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); |
| 1146 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | 1988 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 1147 | private final RuleCall cClassInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | 1989 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); |
| 1148 | private final RuleCall cEnumInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | 1990 | private final RuleCall cIDTerminalRuleCall_0_0 = (RuleCall)cGroup_0.eContents().get(0); |
| 1149 | private final RuleCall cGlobalRelationInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | 1991 | private final Group cGroup_0_1 = (Group)cGroup_0.eContents().get(1); |
| 1150 | 1992 | private final Keyword cFullStopKeyword_0_1_0 = (Keyword)cGroup_0_1.eContents().get(0); | |
| 1151 | ///////////////////// | 1993 | private final RuleCall cIDTerminalRuleCall_0_1_1 = (RuleCall)cGroup_0_1.eContents().get(1); |
| 1152 | //// Advanced Class-Diagram interpretations | 1994 | private final RuleCall cQUOTED_IDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
| 1153 | ///////////////////// | 1995 | |
| 1154 | //CDInterpretation: | 1996 | //QualifiedName hidden(): |
| 1155 | // ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation; | 1997 | // ID ("." ID)* | QUOTED_ID; |
| 1156 | @Override public ParserRule getRule() { return rule; } | 1998 | @Override public ParserRule getRule() { return rule; } |
| 1157 | 1999 | ||
| 1158 | //ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation | 2000 | //ID ("." ID)* | QUOTED_ID |
| 1159 | public Alternatives getAlternatives() { return cAlternatives; } | 2001 | public Alternatives getAlternatives() { return cAlternatives; } |
| 1160 | 2002 | ||
| 1161 | //ClassInterpretation | 2003 | //ID ("." ID)* |
| 1162 | public RuleCall getClassInterpretationParserRuleCall_0() { return cClassInterpretationParserRuleCall_0; } | 2004 | public Group getGroup_0() { return cGroup_0; } |
| 2005 | |||
| 2006 | //ID | ||
| 2007 | public RuleCall getIDTerminalRuleCall_0_0() { return cIDTerminalRuleCall_0_0; } | ||
| 2008 | |||
| 2009 | //("." ID)* | ||
| 2010 | public Group getGroup_0_1() { return cGroup_0_1; } | ||
| 1163 | 2011 | ||
| 1164 | //EnumInterpretation | 2012 | //"." |
| 1165 | public RuleCall getEnumInterpretationParserRuleCall_1() { return cEnumInterpretationParserRuleCall_1; } | 2013 | public Keyword getFullStopKeyword_0_1_0() { return cFullStopKeyword_0_1_0; } |
| 1166 | 2014 | ||
| 1167 | //GlobalRelationInterpretation | 2015 | //ID |
| 1168 | public RuleCall getGlobalRelationInterpretationParserRuleCall_2() { return cGlobalRelationInterpretationParserRuleCall_2; } | 2016 | public RuleCall getIDTerminalRuleCall_0_1_1() { return cIDTerminalRuleCall_0_1_1; } |
| 2017 | |||
| 2018 | //QUOTED_ID | ||
| 2019 | public RuleCall getQUOTED_IDTerminalRuleCall_1() { return cQUOTED_IDTerminalRuleCall_1; } | ||
| 1169 | } | 2020 | } |
| 1170 | public class ClassInterpretationElements extends AbstractParserRuleElementFinder { | 2021 | public class NamedElementElements extends AbstractParserRuleElementFinder { |
| 1171 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClassInterpretation"); | 2022 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NamedElement"); |
| 1172 | private final Group cGroup = (Group)rule.eContents().get(1); | 2023 | private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); |
| 1173 | private final Assignment cAbstractAssignment_0 = (Assignment)cGroup.eContents().get(0); | 2024 | private final RuleCall cNameQualifiedNameParserRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); |
| 1174 | private final Keyword cAbstractAbstractKeyword_0_0 = (Keyword)cAbstractAssignment_0.eContents().get(0); | ||
| 1175 | private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 1176 | private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 1177 | private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0); | ||
| 1178 | private final Group cGroup_3 = (Group)cGroup.eContents().get(3); | ||
| 1179 | private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); | ||
| 1180 | private final Assignment cSupertypesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); | ||
| 1181 | private final RuleCall cSupertypesModelSymbolParserRuleCall_3_1_0 = (RuleCall)cSupertypesAssignment_3_1.eContents().get(0); | ||
| 1182 | private final Keyword cLeftCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); | ||
| 1183 | private final Assignment cFieltAssignment_5 = (Assignment)cGroup.eContents().get(5); | ||
| 1184 | private final RuleCall cFieltFieldRelationInterpretationParserRuleCall_5_0 = (RuleCall)cFieltAssignment_5.eContents().get(0); | ||
| 1185 | private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6); | ||
| 1186 | 2025 | ||
| 1187 | //ClassInterpretation: | 2026 | //NamedElement: |
| 1188 | // abstract?='abstract'? 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' | 2027 | // name=QualifiedName; |
| 1189 | // fielt+=FieldRelationInterpretation* | ||
| 1190 | // '}'; | ||
| 1191 | @Override public ParserRule getRule() { return rule; } | 2028 | @Override public ParserRule getRule() { return rule; } |
| 1192 | 2029 | ||
| 1193 | //abstract?='abstract'? 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' | 2030 | //name=QualifiedName |
| 1194 | //fielt+=FieldRelationInterpretation* '}' | 2031 | public Assignment getNameAssignment() { return cNameAssignment; } |
| 1195 | public Group getGroup() { return cGroup; } | ||
| 1196 | 2032 | ||
| 1197 | //abstract?='abstract'? | 2033 | //QualifiedName |
| 1198 | public Assignment getAbstractAssignment_0() { return cAbstractAssignment_0; } | 2034 | public RuleCall getNameQualifiedNameParserRuleCall_0() { return cNameQualifiedNameParserRuleCall_0; } |
| 2035 | } | ||
| 2036 | |||
| 2037 | public class MetricTypeElements extends AbstractEnumRuleElementFinder { | ||
| 2038 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | ||
| 2039 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2040 | private final EnumLiteralDeclaration cINTEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2041 | private final Keyword cINTIntKeyword_0_0 = (Keyword)cINTEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2042 | private final EnumLiteralDeclaration cREALEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2043 | private final Keyword cREALRealKeyword_1_0 = (Keyword)cREALEnumLiteralDeclaration_1.eContents().get(0); | ||
| 1199 | 2044 | ||
| 1200 | //'abstract' | 2045 | //enum MetricType: |
| 1201 | public Keyword getAbstractAbstractKeyword_0_0() { return cAbstractAbstractKeyword_0_0; } | 2046 | // INT="int" | REAL="real"; |
| 2047 | public EnumRule getRule() { return rule; } | ||
| 1202 | 2048 | ||
| 1203 | //'class' | 2049 | //INT="int" | REAL="real" |
| 1204 | public Keyword getClassKeyword_1() { return cClassKeyword_1; } | 2050 | public Alternatives getAlternatives() { return cAlternatives; } |
| 1205 | 2051 | ||
| 1206 | //symbol=ModelSymbol | 2052 | //INT="int" |
| 1207 | public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; } | 2053 | public EnumLiteralDeclaration getINTEnumLiteralDeclaration_0() { return cINTEnumLiteralDeclaration_0; } |
| 1208 | 2054 | ||
| 1209 | //ModelSymbol | 2055 | //"int" |
| 1210 | public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; } | 2056 | public Keyword getINTIntKeyword_0_0() { return cINTIntKeyword_0_0; } |
| 1211 | 2057 | ||
| 1212 | //('extends' supertypes+=ModelSymbol+)? | 2058 | //REAL="real" |
| 1213 | public Group getGroup_3() { return cGroup_3; } | 2059 | public EnumLiteralDeclaration getREALEnumLiteralDeclaration_1() { return cREALEnumLiteralDeclaration_1; } |
| 1214 | 2060 | ||
| 1215 | //'extends' | 2061 | //"real" |
| 1216 | public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; } | 2062 | public Keyword getREALRealKeyword_1_0() { return cREALRealKeyword_1_0; } |
| 2063 | } | ||
| 2064 | public class BinaryOperatorElements extends AbstractEnumRuleElementFinder { | ||
| 2065 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BinaryOperator"); | ||
| 2066 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2067 | private final EnumLiteralDeclaration cEQEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2068 | private final Keyword cEQEQKeyword_0_0 = (Keyword)cEQEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2069 | private final EnumLiteralDeclaration cNOT_EQEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2070 | private final Keyword cNOT_EQNOT_EQKeyword_1_0 = (Keyword)cNOT_EQEnumLiteralDeclaration_1.eContents().get(0); | ||
| 2071 | private final EnumLiteralDeclaration cLESSEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
| 2072 | private final Keyword cLESSLESSKeyword_2_0 = (Keyword)cLESSEnumLiteralDeclaration_2.eContents().get(0); | ||
| 2073 | private final EnumLiteralDeclaration cLESS_EQEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
| 2074 | private final Keyword cLESS_EQLESS_EQKeyword_3_0 = (Keyword)cLESS_EQEnumLiteralDeclaration_3.eContents().get(0); | ||
| 2075 | private final EnumLiteralDeclaration cGREATEREnumLiteralDeclaration_4 = (EnumLiteralDeclaration)cAlternatives.eContents().get(4); | ||
| 2076 | private final Keyword cGREATERGREATERKeyword_4_0 = (Keyword)cGREATEREnumLiteralDeclaration_4.eContents().get(0); | ||
| 2077 | private final EnumLiteralDeclaration cGREATER_EQEnumLiteralDeclaration_5 = (EnumLiteralDeclaration)cAlternatives.eContents().get(5); | ||
| 2078 | private final Keyword cGREATER_EQGREATER_EQKeyword_5_0 = (Keyword)cGREATER_EQEnumLiteralDeclaration_5.eContents().get(0); | ||
| 2079 | private final EnumLiteralDeclaration cINEnumLiteralDeclaration_6 = (EnumLiteralDeclaration)cAlternatives.eContents().get(6); | ||
| 2080 | private final Keyword cININKeyword_6_0 = (Keyword)cINEnumLiteralDeclaration_6.eContents().get(0); | ||
| 2081 | private final EnumLiteralDeclaration cADDEnumLiteralDeclaration_7 = (EnumLiteralDeclaration)cAlternatives.eContents().get(7); | ||
| 2082 | private final Keyword cADDADDKeyword_7_0 = (Keyword)cADDEnumLiteralDeclaration_7.eContents().get(0); | ||
| 2083 | private final EnumLiteralDeclaration cSUBEnumLiteralDeclaration_8 = (EnumLiteralDeclaration)cAlternatives.eContents().get(8); | ||
| 2084 | private final Keyword cSUBSUBKeyword_8_0 = (Keyword)cSUBEnumLiteralDeclaration_8.eContents().get(0); | ||
| 2085 | private final EnumLiteralDeclaration cMULEnumLiteralDeclaration_9 = (EnumLiteralDeclaration)cAlternatives.eContents().get(9); | ||
| 2086 | private final Keyword cMULMULKeyword_9_0 = (Keyword)cMULEnumLiteralDeclaration_9.eContents().get(0); | ||
| 2087 | private final EnumLiteralDeclaration cDIVEnumLiteralDeclaration_10 = (EnumLiteralDeclaration)cAlternatives.eContents().get(10); | ||
| 2088 | private final Keyword cDIVDIVKeyword_10_0 = (Keyword)cDIVEnumLiteralDeclaration_10.eContents().get(0); | ||
| 2089 | private final EnumLiteralDeclaration cPOWEnumLiteralDeclaration_11 = (EnumLiteralDeclaration)cAlternatives.eContents().get(11); | ||
| 2090 | private final Keyword cPOWPOWKeyword_11_0 = (Keyword)cPOWEnumLiteralDeclaration_11.eContents().get(0); | ||
| 2091 | |||
| 2092 | //enum BinaryOperator: | ||
| 2093 | // EQ | NOT_EQ | LESS | LESS_EQ | GREATER | GREATER_EQ | IN | ADD | SUB | MUL | DIV | POW; | ||
| 2094 | public EnumRule getRule() { return rule; } | ||
| 2095 | |||
| 2096 | //EQ | NOT_EQ | LESS | LESS_EQ | GREATER | GREATER_EQ | IN | ADD | SUB | MUL | DIV | POW | ||
| 2097 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1217 | 2098 | ||
| 1218 | //supertypes+=ModelSymbol+ | 2099 | //EQ |
| 1219 | public Assignment getSupertypesAssignment_3_1() { return cSupertypesAssignment_3_1; } | 2100 | public EnumLiteralDeclaration getEQEnumLiteralDeclaration_0() { return cEQEnumLiteralDeclaration_0; } |
| 1220 | 2101 | ||
| 1221 | //ModelSymbol | 2102 | //"EQ" |
| 1222 | public RuleCall getSupertypesModelSymbolParserRuleCall_3_1_0() { return cSupertypesModelSymbolParserRuleCall_3_1_0; } | 2103 | public Keyword getEQEQKeyword_0_0() { return cEQEQKeyword_0_0; } |
| 1223 | 2104 | ||
| 1224 | //'{' | 2105 | //NOT_EQ |
| 1225 | public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; } | 2106 | public EnumLiteralDeclaration getNOT_EQEnumLiteralDeclaration_1() { return cNOT_EQEnumLiteralDeclaration_1; } |
| 1226 | 2107 | ||
| 1227 | //fielt+=FieldRelationInterpretation* | 2108 | //"NOT_EQ" |
| 1228 | public Assignment getFieltAssignment_5() { return cFieltAssignment_5; } | 2109 | public Keyword getNOT_EQNOT_EQKeyword_1_0() { return cNOT_EQNOT_EQKeyword_1_0; } |
| 1229 | 2110 | ||
| 1230 | //FieldRelationInterpretation | 2111 | //LESS |
| 1231 | public RuleCall getFieltFieldRelationInterpretationParserRuleCall_5_0() { return cFieltFieldRelationInterpretationParserRuleCall_5_0; } | 2112 | public EnumLiteralDeclaration getLESSEnumLiteralDeclaration_2() { return cLESSEnumLiteralDeclaration_2; } |
| 1232 | 2113 | ||
| 1233 | //'}' | 2114 | //"LESS" |
| 1234 | public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; } | 2115 | public Keyword getLESSLESSKeyword_2_0() { return cLESSLESSKeyword_2_0; } |
| 2116 | |||
| 2117 | //LESS_EQ | ||
| 2118 | public EnumLiteralDeclaration getLESS_EQEnumLiteralDeclaration_3() { return cLESS_EQEnumLiteralDeclaration_3; } | ||
| 2119 | |||
| 2120 | //"LESS_EQ" | ||
| 2121 | public Keyword getLESS_EQLESS_EQKeyword_3_0() { return cLESS_EQLESS_EQKeyword_3_0; } | ||
| 2122 | |||
| 2123 | //GREATER | ||
| 2124 | public EnumLiteralDeclaration getGREATEREnumLiteralDeclaration_4() { return cGREATEREnumLiteralDeclaration_4; } | ||
| 2125 | |||
| 2126 | //"GREATER" | ||
| 2127 | public Keyword getGREATERGREATERKeyword_4_0() { return cGREATERGREATERKeyword_4_0; } | ||
| 2128 | |||
| 2129 | //GREATER_EQ | ||
| 2130 | public EnumLiteralDeclaration getGREATER_EQEnumLiteralDeclaration_5() { return cGREATER_EQEnumLiteralDeclaration_5; } | ||
| 2131 | |||
| 2132 | //"GREATER_EQ" | ||
| 2133 | public Keyword getGREATER_EQGREATER_EQKeyword_5_0() { return cGREATER_EQGREATER_EQKeyword_5_0; } | ||
| 2134 | |||
| 2135 | //IN | ||
| 2136 | public EnumLiteralDeclaration getINEnumLiteralDeclaration_6() { return cINEnumLiteralDeclaration_6; } | ||
| 2137 | |||
| 2138 | //"IN" | ||
| 2139 | public Keyword getININKeyword_6_0() { return cININKeyword_6_0; } | ||
| 2140 | |||
| 2141 | //ADD | ||
| 2142 | public EnumLiteralDeclaration getADDEnumLiteralDeclaration_7() { return cADDEnumLiteralDeclaration_7; } | ||
| 2143 | |||
| 2144 | //"ADD" | ||
| 2145 | public Keyword getADDADDKeyword_7_0() { return cADDADDKeyword_7_0; } | ||
| 2146 | |||
| 2147 | //SUB | ||
| 2148 | public EnumLiteralDeclaration getSUBEnumLiteralDeclaration_8() { return cSUBEnumLiteralDeclaration_8; } | ||
| 2149 | |||
| 2150 | //"SUB" | ||
| 2151 | public Keyword getSUBSUBKeyword_8_0() { return cSUBSUBKeyword_8_0; } | ||
| 2152 | |||
| 2153 | //MUL | ||
| 2154 | public EnumLiteralDeclaration getMULEnumLiteralDeclaration_9() { return cMULEnumLiteralDeclaration_9; } | ||
| 2155 | |||
| 2156 | //"MUL" | ||
| 2157 | public Keyword getMULMULKeyword_9_0() { return cMULMULKeyword_9_0; } | ||
| 2158 | |||
| 2159 | //DIV | ||
| 2160 | public EnumLiteralDeclaration getDIVEnumLiteralDeclaration_10() { return cDIVEnumLiteralDeclaration_10; } | ||
| 2161 | |||
| 2162 | //"DIV" | ||
| 2163 | public Keyword getDIVDIVKeyword_10_0() { return cDIVDIVKeyword_10_0; } | ||
| 2164 | |||
| 2165 | //POW | ||
| 2166 | public EnumLiteralDeclaration getPOWEnumLiteralDeclaration_11() { return cPOWEnumLiteralDeclaration_11; } | ||
| 2167 | |||
| 2168 | //"POW" | ||
| 2169 | public Keyword getPOWPOWKeyword_11_0() { return cPOWPOWKeyword_11_0; } | ||
| 1235 | } | 2170 | } |
| 1236 | public class EnumInterpretationElements extends AbstractParserRuleElementFinder { | 2171 | public class ComparisonOperatorElements extends AbstractEnumRuleElementFinder { |
| 1237 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EnumInterpretation"); | 2172 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); |
| 1238 | private final Group cGroup = (Group)rule.eContents().get(1); | 2173 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 1239 | private final Keyword cEnumKeyword_0 = (Keyword)cGroup.eContents().get(0); | 2174 | private final EnumLiteralDeclaration cEQEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); |
| 1240 | private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); | 2175 | private final Keyword cEQEqualsSignEqualsSignKeyword_0_0 = (Keyword)cEQEnumLiteralDeclaration_0.eContents().get(0); |
| 1241 | private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); | 2176 | private final EnumLiteralDeclaration cNOT_EQEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); |
| 1242 | private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); | 2177 | private final Keyword cNOT_EQExclamationMarkEqualsSignKeyword_1_0 = (Keyword)cNOT_EQEnumLiteralDeclaration_1.eContents().get(0); |
| 1243 | private final Assignment cObjectsAssignment_3 = (Assignment)cGroup.eContents().get(3); | 2178 | private final EnumLiteralDeclaration cLESSEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); |
| 1244 | private final RuleCall cObjectsNamedObjectParserRuleCall_3_0 = (RuleCall)cObjectsAssignment_3.eContents().get(0); | 2179 | private final Keyword cLESSLessThanSignKeyword_2_0 = (Keyword)cLESSEnumLiteralDeclaration_2.eContents().get(0); |
| 1245 | private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); | 2180 | private final EnumLiteralDeclaration cLESS_EQEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); |
| 1246 | 2181 | private final Keyword cLESS_EQLessThanSignEqualsSignKeyword_3_0 = (Keyword)cLESS_EQEnumLiteralDeclaration_3.eContents().get(0); | |
| 1247 | //EnumInterpretation: | 2182 | private final EnumLiteralDeclaration cGREATEREnumLiteralDeclaration_4 = (EnumLiteralDeclaration)cAlternatives.eContents().get(4); |
| 1248 | // 'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}'; | 2183 | private final Keyword cGREATERGreaterThanSignKeyword_4_0 = (Keyword)cGREATEREnumLiteralDeclaration_4.eContents().get(0); |
| 1249 | @Override public ParserRule getRule() { return rule; } | 2184 | private final EnumLiteralDeclaration cGREATER_EQEnumLiteralDeclaration_5 = (EnumLiteralDeclaration)cAlternatives.eContents().get(5); |
| 2185 | private final Keyword cGREATER_EQGreaterThanSignEqualsSignKeyword_5_0 = (Keyword)cGREATER_EQEnumLiteralDeclaration_5.eContents().get(0); | ||
| 2186 | private final EnumLiteralDeclaration cINEnumLiteralDeclaration_6 = (EnumLiteralDeclaration)cAlternatives.eContents().get(6); | ||
| 2187 | private final Keyword cINInKeyword_6_0 = (Keyword)cINEnumLiteralDeclaration_6.eContents().get(0); | ||
| 2188 | |||
| 2189 | //enum ComparisonOperator returns BinaryOperator: | ||
| 2190 | // EQ="==" | NOT_EQ="!=" | LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | IN="in"; | ||
| 2191 | public EnumRule getRule() { return rule; } | ||
| 2192 | |||
| 2193 | //EQ="==" | NOT_EQ="!=" | LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | IN="in" | ||
| 2194 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1250 | 2195 | ||
| 1251 | //'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}' | 2196 | //EQ="==" |
| 1252 | public Group getGroup() { return cGroup; } | 2197 | public EnumLiteralDeclaration getEQEnumLiteralDeclaration_0() { return cEQEnumLiteralDeclaration_0; } |
| 2198 | |||
| 2199 | //"==" | ||
| 2200 | public Keyword getEQEqualsSignEqualsSignKeyword_0_0() { return cEQEqualsSignEqualsSignKeyword_0_0; } | ||
| 1253 | 2201 | ||
| 1254 | //'enum' | 2202 | //NOT_EQ="!=" |
| 1255 | public Keyword getEnumKeyword_0() { return cEnumKeyword_0; } | 2203 | public EnumLiteralDeclaration getNOT_EQEnumLiteralDeclaration_1() { return cNOT_EQEnumLiteralDeclaration_1; } |
| 1256 | 2204 | ||
| 1257 | //Symbol=ModelSymbol | 2205 | //"!=" |
| 1258 | public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } | 2206 | public Keyword getNOT_EQExclamationMarkEqualsSignKeyword_1_0() { return cNOT_EQExclamationMarkEqualsSignKeyword_1_0; } |
| 1259 | 2207 | ||
| 1260 | //ModelSymbol | 2208 | //LESS="<" |
| 1261 | public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } | 2209 | public EnumLiteralDeclaration getLESSEnumLiteralDeclaration_2() { return cLESSEnumLiteralDeclaration_2; } |
| 1262 | 2210 | ||
| 1263 | //'{' | 2211 | //"<" |
| 1264 | public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } | 2212 | public Keyword getLESSLessThanSignKeyword_2_0() { return cLESSLessThanSignKeyword_2_0; } |
| 1265 | 2213 | ||
| 1266 | //objects+=NamedObject+ | 2214 | //LESS_EQ="<=" |
| 1267 | public Assignment getObjectsAssignment_3() { return cObjectsAssignment_3; } | 2215 | public EnumLiteralDeclaration getLESS_EQEnumLiteralDeclaration_3() { return cLESS_EQEnumLiteralDeclaration_3; } |
| 1268 | 2216 | ||
| 1269 | //NamedObject | 2217 | //"<=" |
| 1270 | public RuleCall getObjectsNamedObjectParserRuleCall_3_0() { return cObjectsNamedObjectParserRuleCall_3_0; } | 2218 | public Keyword getLESS_EQLessThanSignEqualsSignKeyword_3_0() { return cLESS_EQLessThanSignEqualsSignKeyword_3_0; } |
| 1271 | 2219 | ||
| 1272 | //'}' | 2220 | //GREATER=">" |
| 1273 | public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } | 2221 | public EnumLiteralDeclaration getGREATEREnumLiteralDeclaration_4() { return cGREATEREnumLiteralDeclaration_4; } |
| 2222 | |||
| 2223 | //">" | ||
| 2224 | public Keyword getGREATERGreaterThanSignKeyword_4_0() { return cGREATERGreaterThanSignKeyword_4_0; } | ||
| 2225 | |||
| 2226 | //GREATER_EQ=">=" | ||
| 2227 | public EnumLiteralDeclaration getGREATER_EQEnumLiteralDeclaration_5() { return cGREATER_EQEnumLiteralDeclaration_5; } | ||
| 2228 | |||
| 2229 | //">=" | ||
| 2230 | public Keyword getGREATER_EQGreaterThanSignEqualsSignKeyword_5_0() { return cGREATER_EQGreaterThanSignEqualsSignKeyword_5_0; } | ||
| 2231 | |||
| 2232 | //IN="in" | ||
| 2233 | public EnumLiteralDeclaration getINEnumLiteralDeclaration_6() { return cINEnumLiteralDeclaration_6; } | ||
| 2234 | |||
| 2235 | //"in" | ||
| 2236 | public Keyword getINInKeyword_6_0() { return cINInKeyword_6_0; } | ||
| 1274 | } | 2237 | } |
| 1275 | public class FieldRelationInterpretationElements extends AbstractParserRuleElementFinder { | 2238 | public class AdditiveBinaryOperatorElements extends AbstractEnumRuleElementFinder { |
| 1276 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); | 2239 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); |
| 1277 | private final Group cGroup = (Group)rule.eContents().get(1); | 2240 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 1278 | private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0); | 2241 | private final EnumLiteralDeclaration cADDEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); |
| 1279 | private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0); | 2242 | private final Keyword cADDPlusSignKeyword_0_0 = (Keyword)cADDEnumLiteralDeclaration_0.eContents().get(0); |
| 1280 | private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); | 2243 | private final EnumLiteralDeclaration cSUBEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); |
| 1281 | private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); | 2244 | private final Keyword cSUBHyphenMinusKeyword_1_0 = (Keyword)cSUBEnumLiteralDeclaration_1.eContents().get(0); |
| 1282 | private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
| 1283 | private final Assignment cMultiplicityAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
| 1284 | private final RuleCall cMultiplicityMultiplicityDefinitionParserRuleCall_3_0 = (RuleCall)cMultiplicityAssignment_3.eContents().get(0); | ||
| 1285 | private final Assignment cTargetAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
| 1286 | private final RuleCall cTargetSymbolParserRuleCall_4_0 = (RuleCall)cTargetAssignment_4.eContents().get(0); | ||
| 1287 | 2245 | ||
| 1288 | //FieldRelationInterpretation: | 2246 | //enum AdditiveBinaryOperator returns BinaryOperator: |
| 1289 | // containment?='containment'? symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol; | 2247 | // ADD="+" | SUB="-"; |
| 1290 | @Override public ParserRule getRule() { return rule; } | 2248 | public EnumRule getRule() { return rule; } |
| 1291 | 2249 | ||
| 1292 | //containment?='containment'? symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol | 2250 | //ADD="+" | SUB="-" |
| 1293 | public Group getGroup() { return cGroup; } | 2251 | public Alternatives getAlternatives() { return cAlternatives; } |
| 1294 | 2252 | ||
| 1295 | //containment?='containment'? | 2253 | //ADD="+" |
| 1296 | public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; } | 2254 | public EnumLiteralDeclaration getADDEnumLiteralDeclaration_0() { return cADDEnumLiteralDeclaration_0; } |
| 1297 | 2255 | ||
| 1298 | //'containment' | 2256 | //"+" |
| 1299 | public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; } | 2257 | public Keyword getADDPlusSignKeyword_0_0() { return cADDPlusSignKeyword_0_0; } |
| 1300 | 2258 | ||
| 1301 | //symbol=ModelSymbol | 2259 | //SUB="-" |
| 1302 | public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } | 2260 | public EnumLiteralDeclaration getSUBEnumLiteralDeclaration_1() { return cSUBEnumLiteralDeclaration_1; } |
| 1303 | 2261 | ||
| 1304 | //ModelSymbol | 2262 | //"-" |
| 1305 | public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } | 2263 | public Keyword getSUBHyphenMinusKeyword_1_0() { return cSUBHyphenMinusKeyword_1_0; } |
| 2264 | } | ||
| 2265 | public class MultiplicativeBinaryOperatorElements extends AbstractEnumRuleElementFinder { | ||
| 2266 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
| 2267 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2268 | private final EnumLiteralDeclaration cMULEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2269 | private final Keyword cMULAsteriskKeyword_0_0 = (Keyword)cMULEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2270 | private final EnumLiteralDeclaration cDIVEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2271 | private final Keyword cDIVSolidusKeyword_1_0 = (Keyword)cDIVEnumLiteralDeclaration_1.eContents().get(0); | ||
| 1306 | 2272 | ||
| 1307 | //':' | 2273 | //enum MultiplicativeBinaryOperator returns BinaryOperator: |
| 1308 | public Keyword getColonKeyword_2() { return cColonKeyword_2; } | 2274 | // MUL="*" | DIV="/"; |
| 2275 | public EnumRule getRule() { return rule; } | ||
| 1309 | 2276 | ||
| 1310 | //multiplicity=MultiplicityDefinition? | 2277 | //MUL="*" | DIV="/" |
| 1311 | public Assignment getMultiplicityAssignment_3() { return cMultiplicityAssignment_3; } | 2278 | public Alternatives getAlternatives() { return cAlternatives; } |
| 2279 | |||
| 2280 | //MUL="*" | ||
| 2281 | public EnumLiteralDeclaration getMULEnumLiteralDeclaration_0() { return cMULEnumLiteralDeclaration_0; } | ||
| 1312 | 2282 | ||
| 1313 | //MultiplicityDefinition | 2283 | //"*" |
| 1314 | public RuleCall getMultiplicityMultiplicityDefinitionParserRuleCall_3_0() { return cMultiplicityMultiplicityDefinitionParserRuleCall_3_0; } | 2284 | public Keyword getMULAsteriskKeyword_0_0() { return cMULAsteriskKeyword_0_0; } |
| 1315 | 2285 | ||
| 1316 | //target=Symbol | 2286 | //DIV="/" |
| 1317 | public Assignment getTargetAssignment_4() { return cTargetAssignment_4; } | 2287 | public EnumLiteralDeclaration getDIVEnumLiteralDeclaration_1() { return cDIVEnumLiteralDeclaration_1; } |
| 1318 | 2288 | ||
| 1319 | //Symbol | 2289 | //"/" |
| 1320 | public RuleCall getTargetSymbolParserRuleCall_4_0() { return cTargetSymbolParserRuleCall_4_0; } | 2290 | public Keyword getDIVSolidusKeyword_1_0() { return cDIVSolidusKeyword_1_0; } |
| 1321 | } | 2291 | } |
| 1322 | public class GlobalRelationInterpretationElements extends AbstractParserRuleElementFinder { | 2292 | public class ExponentialOpElements extends AbstractEnumRuleElementFinder { |
| 1323 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.GlobalRelationInterpretation"); | 2293 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); |
| 1324 | private final Group cGroup = (Group)rule.eContents().get(1); | 2294 | private final EnumLiteralDeclaration cPOWEnumLiteralDeclaration = (EnumLiteralDeclaration)rule.eContents().get(1); |
| 1325 | private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0); | 2295 | private final Keyword cPOWCircumflexAccentKeyword_0 = (Keyword)cPOWEnumLiteralDeclaration.eContents().get(0); |
| 1326 | private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0); | ||
| 1327 | private final Keyword cRelationKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
| 1328 | private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
| 1329 | private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0); | ||
| 1330 | private final Keyword cColonKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
| 1331 | private final Assignment cSourceMultiplicityAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
| 1332 | private final RuleCall cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0 = (RuleCall)cSourceMultiplicityAssignment_4.eContents().get(0); | ||
| 1333 | private final Assignment cSourceAssignment_5 = (Assignment)cGroup.eContents().get(5); | ||
| 1334 | private final RuleCall cSourceSymbolParserRuleCall_5_0 = (RuleCall)cSourceAssignment_5.eContents().get(0); | ||
| 1335 | private final Assignment cTargetMultiplicityAssignment_6 = (Assignment)cGroup.eContents().get(6); | ||
| 1336 | private final RuleCall cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0 = (RuleCall)cTargetMultiplicityAssignment_6.eContents().get(0); | ||
| 1337 | private final Assignment cTargetAssignment_7 = (Assignment)cGroup.eContents().get(7); | ||
| 1338 | private final RuleCall cTargetSymbolParserRuleCall_7_0 = (RuleCall)cTargetAssignment_7.eContents().get(0); | ||
| 1339 | |||
| 1340 | //GlobalRelationInterpretation: | ||
| 1341 | // containment?='containment'? 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? | ||
| 1342 | // source=Symbol targetMultiplicity=MultiplicityDefinition? target=Symbol; | ||
| 1343 | @Override public ParserRule getRule() { return rule; } | ||
| 1344 | 2296 | ||
| 1345 | //containment?='containment'? 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol | 2297 | //enum ExponentialOp returns BinaryOperator: |
| 1346 | //targetMultiplicity=MultiplicityDefinition? target=Symbol | 2298 | // POW="^"; |
| 1347 | public Group getGroup() { return cGroup; } | 2299 | public EnumRule getRule() { return rule; } |
| 1348 | 2300 | ||
| 1349 | //containment?='containment'? | 2301 | //POW="^" |
| 1350 | public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; } | 2302 | public EnumLiteralDeclaration getPOWEnumLiteralDeclaration() { return cPOWEnumLiteralDeclaration; } |
| 1351 | 2303 | ||
| 1352 | //'containment' | 2304 | //"^" |
| 1353 | public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; } | 2305 | public Keyword getPOWCircumflexAccentKeyword_0() { return cPOWCircumflexAccentKeyword_0; } |
| 2306 | } | ||
| 2307 | public class UnaryOpElements extends AbstractEnumRuleElementFinder { | ||
| 2308 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | ||
| 2309 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2310 | private final EnumLiteralDeclaration cNEGEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2311 | private final Keyword cNEGExclamationMarkKeyword_0_0 = (Keyword)cNEGEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2312 | private final EnumLiteralDeclaration cPLUSEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2313 | private final Keyword cPLUSPlusSignKeyword_1_0 = (Keyword)cPLUSEnumLiteralDeclaration_1.eContents().get(0); | ||
| 2314 | private final EnumLiteralDeclaration cMINUSEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
| 2315 | private final Keyword cMINUSHyphenMinusKeyword_2_0 = (Keyword)cMINUSEnumLiteralDeclaration_2.eContents().get(0); | ||
| 2316 | private final EnumLiteralDeclaration cMAYEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
| 2317 | private final Keyword cMAYMayKeyword_3_0 = (Keyword)cMAYEnumLiteralDeclaration_3.eContents().get(0); | ||
| 2318 | private final EnumLiteralDeclaration cMUSTEnumLiteralDeclaration_4 = (EnumLiteralDeclaration)cAlternatives.eContents().get(4); | ||
| 2319 | private final Keyword cMUSTMustKeyword_4_0 = (Keyword)cMUSTEnumLiteralDeclaration_4.eContents().get(0); | ||
| 2320 | private final EnumLiteralDeclaration cCURRENTEnumLiteralDeclaration_5 = (EnumLiteralDeclaration)cAlternatives.eContents().get(5); | ||
| 2321 | private final Keyword cCURRENTCurrentKeyword_5_0 = (Keyword)cCURRENTEnumLiteralDeclaration_5.eContents().get(0); | ||
| 2322 | |||
| 2323 | //enum UnaryOp: | ||
| 2324 | // NEG="!" | PLUS="+" | MINUS="-" | MAY="may" | MUST="must" | CURRENT="current"; | ||
| 2325 | public EnumRule getRule() { return rule; } | ||
| 2326 | |||
| 2327 | //NEG="!" | PLUS="+" | MINUS="-" | MAY="may" | MUST="must" | CURRENT="current" | ||
| 2328 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1354 | 2329 | ||
| 1355 | //'relation' | 2330 | //NEG="!" |
| 1356 | public Keyword getRelationKeyword_1() { return cRelationKeyword_1; } | 2331 | public EnumLiteralDeclaration getNEGEnumLiteralDeclaration_0() { return cNEGEnumLiteralDeclaration_0; } |
| 1357 | 2332 | ||
| 1358 | //symbol=ModelSymbol | 2333 | //"!" |
| 1359 | public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; } | 2334 | public Keyword getNEGExclamationMarkKeyword_0_0() { return cNEGExclamationMarkKeyword_0_0; } |
| 1360 | 2335 | ||
| 1361 | //ModelSymbol | 2336 | //PLUS="+" |
| 1362 | public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; } | 2337 | public EnumLiteralDeclaration getPLUSEnumLiteralDeclaration_1() { return cPLUSEnumLiteralDeclaration_1; } |
| 1363 | 2338 | ||
| 1364 | //':' | 2339 | //"+" |
| 1365 | public Keyword getColonKeyword_3() { return cColonKeyword_3; } | 2340 | public Keyword getPLUSPlusSignKeyword_1_0() { return cPLUSPlusSignKeyword_1_0; } |
| 1366 | 2341 | ||
| 1367 | //sourceMultiplicity=MultiplicityDefinition? | 2342 | //MINUS="-" |
| 1368 | public Assignment getSourceMultiplicityAssignment_4() { return cSourceMultiplicityAssignment_4; } | 2343 | public EnumLiteralDeclaration getMINUSEnumLiteralDeclaration_2() { return cMINUSEnumLiteralDeclaration_2; } |
| 1369 | 2344 | ||
| 1370 | //MultiplicityDefinition | 2345 | //"-" |
| 1371 | public RuleCall getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0() { return cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0; } | 2346 | public Keyword getMINUSHyphenMinusKeyword_2_0() { return cMINUSHyphenMinusKeyword_2_0; } |
| 1372 | 2347 | ||
| 1373 | //source=Symbol | 2348 | //MAY="may" |
| 1374 | public Assignment getSourceAssignment_5() { return cSourceAssignment_5; } | 2349 | public EnumLiteralDeclaration getMAYEnumLiteralDeclaration_3() { return cMAYEnumLiteralDeclaration_3; } |
| 1375 | 2350 | ||
| 1376 | //Symbol | 2351 | //"may" |
| 1377 | public RuleCall getSourceSymbolParserRuleCall_5_0() { return cSourceSymbolParserRuleCall_5_0; } | 2352 | public Keyword getMAYMayKeyword_3_0() { return cMAYMayKeyword_3_0; } |
| 1378 | 2353 | ||
| 1379 | //targetMultiplicity=MultiplicityDefinition? | 2354 | //MUST="must" |
| 1380 | public Assignment getTargetMultiplicityAssignment_6() { return cTargetMultiplicityAssignment_6; } | 2355 | public EnumLiteralDeclaration getMUSTEnumLiteralDeclaration_4() { return cMUSTEnumLiteralDeclaration_4; } |
| 1381 | 2356 | ||
| 1382 | //MultiplicityDefinition | 2357 | //"must" |
| 1383 | public RuleCall getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0() { return cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0; } | 2358 | public Keyword getMUSTMustKeyword_4_0() { return cMUSTMustKeyword_4_0; } |
| 1384 | 2359 | ||
| 1385 | //target=Symbol | 2360 | //CURRENT="current" |
| 1386 | public Assignment getTargetAssignment_7() { return cTargetAssignment_7; } | 2361 | public EnumLiteralDeclaration getCURRENTEnumLiteralDeclaration_5() { return cCURRENTEnumLiteralDeclaration_5; } |
| 1387 | 2362 | ||
| 1388 | //Symbol | 2363 | //"current" |
| 1389 | public RuleCall getTargetSymbolParserRuleCall_7_0() { return cTargetSymbolParserRuleCall_7_0; } | 2364 | public Keyword getCURRENTCurrentKeyword_5_0() { return cCURRENTCurrentKeyword_5_0; } |
| 1390 | } | 2365 | } |
| 1391 | public class MultiplicityDefinitionElements extends AbstractParserRuleElementFinder { | 2366 | public class AggregationOpElements extends AbstractEnumRuleElementFinder { |
| 1392 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); | 2367 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); |
| 1393 | private final Group cGroup = (Group)rule.eContents().get(1); | 2368 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
| 1394 | private final Assignment cLowerAssignment_0 = (Assignment)cGroup.eContents().get(0); | 2369 | private final EnumLiteralDeclaration cONLYEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); |
| 1395 | private final RuleCall cLowerINTTerminalRuleCall_0_0 = (RuleCall)cLowerAssignment_0.eContents().get(0); | 2370 | private final Keyword cONLYOnlyKeyword_0_0 = (Keyword)cONLYEnumLiteralDeclaration_0.eContents().get(0); |
| 1396 | private final Keyword cFullStopFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); | 2371 | private final EnumLiteralDeclaration cSUMEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); |
| 1397 | private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); | 2372 | private final Keyword cSUMSumKeyword_1_0 = (Keyword)cSUMEnumLiteralDeclaration_1.eContents().get(0); |
| 1398 | private final Assignment cUpperAssignment_2_0 = (Assignment)cAlternatives_2.eContents().get(0); | 2373 | private final EnumLiteralDeclaration cPRODEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); |
| 1399 | private final RuleCall cUpperINTTerminalRuleCall_2_0_0 = (RuleCall)cUpperAssignment_2_0.eContents().get(0); | 2374 | private final Keyword cPRODProdKeyword_2_0 = (Keyword)cPRODEnumLiteralDeclaration_2.eContents().get(0); |
| 1400 | private final Assignment cUnlimitedUpperAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1); | 2375 | private final EnumLiteralDeclaration cAVGEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); |
| 1401 | private final Keyword cUnlimitedUpperAsteriskKeyword_2_1_0 = (Keyword)cUnlimitedUpperAssignment_2_1.eContents().get(0); | 2376 | private final Keyword cAVGAvgKeyword_3_0 = (Keyword)cAVGEnumLiteralDeclaration_3.eContents().get(0); |
| 1402 | 2377 | private final EnumLiteralDeclaration cMINEnumLiteralDeclaration_4 = (EnumLiteralDeclaration)cAlternatives.eContents().get(4); | |
| 1403 | //MultiplicityDefinition: | 2378 | private final Keyword cMINMinKeyword_4_0 = (Keyword)cMINEnumLiteralDeclaration_4.eContents().get(0); |
| 1404 | // lower=INT '..' (upper=INT | unlimitedUpper?='*'); | 2379 | private final EnumLiteralDeclaration cMAXEnumLiteralDeclaration_5 = (EnumLiteralDeclaration)cAlternatives.eContents().get(5); |
| 1405 | @Override public ParserRule getRule() { return rule; } | 2380 | private final Keyword cMAXMaxKeyword_5_0 = (Keyword)cMAXEnumLiteralDeclaration_5.eContents().get(0); |
| 2381 | |||
| 2382 | //enum AggregationOp: | ||
| 2383 | // ONLY="only" | SUM="sum" | PROD="prod" | AVG="avg" | MIN="min" | MAX="max"; | ||
| 2384 | public EnumRule getRule() { return rule; } | ||
| 2385 | |||
| 2386 | //ONLY="only" | SUM="sum" | PROD="prod" | AVG="avg" | MIN="min" | MAX="max" | ||
| 2387 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 1406 | 2388 | ||
| 1407 | //lower=INT '..' (upper=INT | unlimitedUpper?='*') | 2389 | //ONLY="only" |
| 1408 | public Group getGroup() { return cGroup; } | 2390 | public EnumLiteralDeclaration getONLYEnumLiteralDeclaration_0() { return cONLYEnumLiteralDeclaration_0; } |
| 1409 | 2391 | ||
| 1410 | //lower=INT | 2392 | //"only" |
| 1411 | public Assignment getLowerAssignment_0() { return cLowerAssignment_0; } | 2393 | public Keyword getONLYOnlyKeyword_0_0() { return cONLYOnlyKeyword_0_0; } |
| 1412 | 2394 | ||
| 1413 | //INT | 2395 | //SUM="sum" |
| 1414 | public RuleCall getLowerINTTerminalRuleCall_0_0() { return cLowerINTTerminalRuleCall_0_0; } | 2396 | public EnumLiteralDeclaration getSUMEnumLiteralDeclaration_1() { return cSUMEnumLiteralDeclaration_1; } |
| 1415 | 2397 | ||
| 1416 | //'..' | 2398 | //"sum" |
| 1417 | public Keyword getFullStopFullStopKeyword_1() { return cFullStopFullStopKeyword_1; } | 2399 | public Keyword getSUMSumKeyword_1_0() { return cSUMSumKeyword_1_0; } |
| 1418 | 2400 | ||
| 1419 | //upper=INT | unlimitedUpper?='*' | 2401 | //PROD="prod" |
| 1420 | public Alternatives getAlternatives_2() { return cAlternatives_2; } | 2402 | public EnumLiteralDeclaration getPRODEnumLiteralDeclaration_2() { return cPRODEnumLiteralDeclaration_2; } |
| 1421 | 2403 | ||
| 1422 | //upper=INT | 2404 | //"prod" |
| 1423 | public Assignment getUpperAssignment_2_0() { return cUpperAssignment_2_0; } | 2405 | public Keyword getPRODProdKeyword_2_0() { return cPRODProdKeyword_2_0; } |
| 1424 | 2406 | ||
| 1425 | //INT | 2407 | //AVG="avg" |
| 1426 | public RuleCall getUpperINTTerminalRuleCall_2_0_0() { return cUpperINTTerminalRuleCall_2_0_0; } | 2408 | public EnumLiteralDeclaration getAVGEnumLiteralDeclaration_3() { return cAVGEnumLiteralDeclaration_3; } |
| 2409 | |||
| 2410 | //"avg" | ||
| 2411 | public Keyword getAVGAvgKeyword_3_0() { return cAVGAvgKeyword_3_0; } | ||
| 2412 | |||
| 2413 | //MIN="min" | ||
| 2414 | public EnumLiteralDeclaration getMINEnumLiteralDeclaration_4() { return cMINEnumLiteralDeclaration_4; } | ||
| 1427 | 2415 | ||
| 1428 | //unlimitedUpper?='*' | 2416 | //"min" |
| 1429 | public Assignment getUnlimitedUpperAssignment_2_1() { return cUnlimitedUpperAssignment_2_1; } | 2417 | public Keyword getMINMinKeyword_4_0() { return cMINMinKeyword_4_0; } |
| 1430 | 2418 | ||
| 1431 | //'*' | 2419 | //MAX="max" |
| 1432 | public Keyword getUnlimitedUpperAsteriskKeyword_2_1_0() { return cUnlimitedUpperAsteriskKeyword_2_1_0; } | 2420 | public EnumLiteralDeclaration getMAXEnumLiteralDeclaration_5() { return cMAXEnumLiteralDeclaration_5; } |
| 2421 | |||
| 2422 | //"max" | ||
| 2423 | public Keyword getMAXMaxKeyword_5_0() { return cMAXMaxKeyword_5_0; } | ||
| 2424 | } | ||
| 2425 | public class LogicValueElements extends AbstractEnumRuleElementFinder { | ||
| 2426 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
| 2427 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2428 | private final EnumLiteralDeclaration cTRUEEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2429 | private final Keyword cTRUETrueKeyword_0_0 = (Keyword)cTRUEEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2430 | private final EnumLiteralDeclaration cFALSEEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2431 | private final Keyword cFALSEFalseKeyword_1_0 = (Keyword)cFALSEEnumLiteralDeclaration_1.eContents().get(0); | ||
| 2432 | private final EnumLiteralDeclaration cUNKNOWNEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
| 2433 | private final Keyword cUNKNOWNUnknownKeyword_2_0 = (Keyword)cUNKNOWNEnumLiteralDeclaration_2.eContents().get(0); | ||
| 2434 | private final EnumLiteralDeclaration cERROREnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
| 2435 | private final Keyword cERRORErrorKeyword_3_0 = (Keyword)cERROREnumLiteralDeclaration_3.eContents().get(0); | ||
| 2436 | |||
| 2437 | //enum LogicValue: | ||
| 2438 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error"; | ||
| 2439 | public EnumRule getRule() { return rule; } | ||
| 2440 | |||
| 2441 | //TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error" | ||
| 2442 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 2443 | |||
| 2444 | //TRUE="true" | ||
| 2445 | public EnumLiteralDeclaration getTRUEEnumLiteralDeclaration_0() { return cTRUEEnumLiteralDeclaration_0; } | ||
| 2446 | |||
| 2447 | //"true" | ||
| 2448 | public Keyword getTRUETrueKeyword_0_0() { return cTRUETrueKeyword_0_0; } | ||
| 2449 | |||
| 2450 | //FALSE="false" | ||
| 2451 | public EnumLiteralDeclaration getFALSEEnumLiteralDeclaration_1() { return cFALSEEnumLiteralDeclaration_1; } | ||
| 2452 | |||
| 2453 | //"false" | ||
| 2454 | public Keyword getFALSEFalseKeyword_1_0() { return cFALSEFalseKeyword_1_0; } | ||
| 2455 | |||
| 2456 | //UNKNOWN="unknown" | ||
| 2457 | public EnumLiteralDeclaration getUNKNOWNEnumLiteralDeclaration_2() { return cUNKNOWNEnumLiteralDeclaration_2; } | ||
| 2458 | |||
| 2459 | //"unknown" | ||
| 2460 | public Keyword getUNKNOWNUnknownKeyword_2_0() { return cUNKNOWNUnknownKeyword_2_0; } | ||
| 2461 | |||
| 2462 | //ERROR="error" | ||
| 2463 | public EnumLiteralDeclaration getERROREnumLiteralDeclaration_3() { return cERROREnumLiteralDeclaration_3; } | ||
| 2464 | |||
| 2465 | //"error" | ||
| 2466 | public Keyword getERRORErrorKeyword_3_0() { return cERRORErrorKeyword_3_0; } | ||
| 2467 | } | ||
| 2468 | public class ObjectiveKindElements extends AbstractEnumRuleElementFinder { | ||
| 2469 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
| 2470 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
| 2471 | private final EnumLiteralDeclaration cMINIMIZEEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
| 2472 | private final Keyword cMINIMIZEMinimizeKeyword_0_0 = (Keyword)cMINIMIZEEnumLiteralDeclaration_0.eContents().get(0); | ||
| 2473 | private final EnumLiteralDeclaration cMAXIMIZEEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
| 2474 | private final Keyword cMAXIMIZEMaximizeKeyword_1_0 = (Keyword)cMAXIMIZEEnumLiteralDeclaration_1.eContents().get(0); | ||
| 2475 | |||
| 2476 | //enum ObjectiveKind: | ||
| 2477 | // MINIMIZE="minimize" | MAXIMIZE="maximize"; | ||
| 2478 | public EnumRule getRule() { return rule; } | ||
| 2479 | |||
| 2480 | //MINIMIZE="minimize" | MAXIMIZE="maximize" | ||
| 2481 | public Alternatives getAlternatives() { return cAlternatives; } | ||
| 2482 | |||
| 2483 | //MINIMIZE="minimize" | ||
| 2484 | public EnumLiteralDeclaration getMINIMIZEEnumLiteralDeclaration_0() { return cMINIMIZEEnumLiteralDeclaration_0; } | ||
| 2485 | |||
| 2486 | //"minimize" | ||
| 2487 | public Keyword getMINIMIZEMinimizeKeyword_0_0() { return cMINIMIZEMinimizeKeyword_0_0; } | ||
| 2488 | |||
| 2489 | //MAXIMIZE="maximize" | ||
| 2490 | public EnumLiteralDeclaration getMAXIMIZEEnumLiteralDeclaration_1() { return cMAXIMIZEEnumLiteralDeclaration_1; } | ||
| 2491 | |||
| 2492 | //"maximize" | ||
| 2493 | public Keyword getMAXIMIZEMaximizeKeyword_1_0() { return cMAXIMIZEMaximizeKeyword_1_0; } | ||
| 1433 | } | 2494 | } |
| 1434 | |||
| 1435 | 2495 | ||
| 1436 | private final ProblemElements pProblem; | 2496 | private final ProblemElements pProblem; |
| 1437 | private final StatementElements pStatement; | 2497 | private final StatementElements pStatement; |
| 1438 | private final TerminalRule tSTRING; | 2498 | private final AssertionOrDefinitionElements pAssertionOrDefinition; |
| 1439 | private final REALLiteralElements pREALLiteral; | 2499 | private final PredicateDefinitionElements pPredicateDefinition; |
| 1440 | private final INTLiteralElements pINTLiteral; | 2500 | private final UnnamedErrorPrediateDefinitionElements pUnnamedErrorPrediateDefinition; |
| 1441 | private final BooleanValueElements pBooleanValue; | 2501 | private final DefaultDefinitionElements pDefaultDefinition; |
| 1442 | private final TruthValueElements pTruthValue; | 2502 | private final ExternPredicateDefinitionElements pExternPredicateDefinition; |
| 1443 | private final InterpretationElements pInterpretation; | 2503 | private final MetricTypeElements eMetricType; |
| 1444 | private final BasicInterpretationElements pBasicInterpretation; | 2504 | private final MetricDefinitionElements pMetricDefinition; |
| 1445 | private final SymbolElements pSymbol; | 2505 | private final ExternMetricDefinitionElements pExternMetricDefinition; |
| 1446 | private final ModelSymbolElements pModelSymbol; | 2506 | private final ExpressionElements pExpression; |
| 1447 | private final PartialitySymbolElements pPartialitySymbol; | 2507 | private final IfElseElements pIfElse; |
| 1448 | private final ExistSymbolElements pExistSymbol; | 2508 | private final DisjunctiveExpressionElements pDisjunctiveExpression; |
| 1449 | private final EqualsSymbolElements pEqualsSymbol; | 2509 | private final CaseElements pCase; |
| 1450 | private final DataSymbolElements pDataSymbol; | 2510 | private final ConjunctiveExpressionElements pConjunctiveExpression; |
| 1451 | private final BooleanSymbolElements pBooleanSymbol; | 2511 | private final BinaryOperatorElements eBinaryOperator; |
| 1452 | private final IntegerSymbolElements pIntegerSymbol; | 2512 | private final ComparisonOperatorElements eComparisonOperator; |
| 1453 | private final RealSymbolElements pRealSymbol; | 2513 | private final ComparisonExpressionElements pComparisonExpression; |
| 1454 | private final StringSymbolElements pStringSymbol; | 2514 | private final AdditiveBinaryOperatorElements eAdditiveBinaryOperator; |
| 1455 | private final ComplexObjectElements pComplexObject; | 2515 | private final AdditiveExpressionElements pAdditiveExpression; |
| 1456 | private final ObjectElements pObject; | 2516 | private final MultiplicativeBinaryOperatorElements eMultiplicativeBinaryOperator; |
| 1457 | private final NamedObjectElements pNamedObject; | 2517 | private final MultiplicativeExpressionElements pMultiplicativeExpression; |
| 1458 | private final UnnamedObjectElements pUnnamedObject; | 2518 | private final ExponentialOpElements eExponentialOp; |
| 1459 | private final DataObjectElements pDataObject; | 2519 | private final ExponentialExpressionElements pExponentialExpression; |
| 1460 | private final BooleanObjectElements pBooleanObject; | 2520 | private final UnaryOpElements eUnaryOp; |
| 1461 | private final IntObjectElements pIntObject; | 2521 | private final UnaryExpressionElements pUnaryExpression; |
| 1462 | private final RealObjectElements pRealObject; | 2522 | private final AggregationExpressionElements pAggregationExpression; |
| 1463 | private final StringObjectElements pStringObject; | 2523 | private final CountElements pCount; |
| 1464 | private final PredicateElements pPredicate; | 2524 | private final AggregationOpElements eAggregationOp; |
| 1465 | private final ParameterElements pParameter; | 2525 | private final AggregationElements pAggregation; |
| 1466 | private final PatternBodyElements pPatternBody; | 2526 | private final AtomicExpressionElements pAtomicExpression; |
| 1467 | private final PolarityElements pPolarity; | 2527 | private final CallElements pCall; |
| 1468 | private final ConstraintElements pConstraint; | 2528 | private final ArgumentListElements pArgumentList; |
| 1469 | private final ClosureTypeElements pClosureType; | 2529 | private final ArgumentElements pArgument; |
| 2530 | private final ExpressionArgumentElements pExpressionArgument; | ||
| 2531 | private final StarArgumentElements pStarArgument; | ||
| 2532 | private final TypedArgumentElements pTypedArgument; | ||
| 2533 | private final TypedStarArgumentElements pTypedStarArgument; | ||
| 2534 | private final ReferenceElements pReference; | ||
| 2535 | private final IntervalElements pInterval; | ||
| 1470 | private final LiteralElements pLiteral; | 2536 | private final LiteralElements pLiteral; |
| 1471 | private final VariableElements pVariable; | 2537 | private final LogicValueElements eLogicValue; |
| 1472 | private final AllInstancesElements pAllInstances; | 2538 | private final LogicLiteralElements pLogicLiteral; |
| 1473 | private final AllObjectsElements pAllObjects; | 2539 | private final NumericLiteralElements pNumericLiteral; |
| 1474 | private final DefaultInterpretationElements pDefaultInterpretation; | 2540 | private final InfinityLiteralElements pInfinityLiteral; |
| 1475 | private final CDInterpretationElements pCDInterpretation; | 2541 | private final EmptyIntervalLiteralElements pEmptyIntervalLiteral; |
| 1476 | private final ClassInterpretationElements pClassInterpretation; | 2542 | private final StringLiteralElements pStringLiteral; |
| 1477 | private final EnumInterpretationElements pEnumInterpretation; | 2543 | private final ClassDefinitionElements pClassDefinition; |
| 1478 | private final FieldRelationInterpretationElements pFieldRelationInterpretation; | 2544 | private final MemberDefinitionElements pMemberDefinition; |
| 1479 | private final GlobalRelationInterpretationElements pGlobalRelationInterpretation; | 2545 | private final MultiplicityElements pMultiplicity; |
| 1480 | private final MultiplicityDefinitionElements pMultiplicityDefinition; | 2546 | private final ManyMultiplicityElements pManyMultiplicity; |
| 2547 | private final ExactMultiplicityElements pExactMultiplicity; | ||
| 2548 | private final BoundedMultiplicityElements pBoundedMultiplicity; | ||
| 2549 | private final ScopeDefinitionElements pScopeDefinition; | ||
| 2550 | private final ExactScopeDefinitionElements pExactScopeDefinition; | ||
| 2551 | private final BoundedScopeDefinitionElements pBoundedScopeDefinition; | ||
| 2552 | private final LowerBoundedScopeDefinitionElements pLowerBoundedScopeDefinition; | ||
| 2553 | private final ObjectiveKindElements eObjectiveKind; | ||
| 2554 | private final ObjectiveDefinitionElements pObjectiveDefinition; | ||
| 2555 | private final UpperMultiplictyElements pUpperMultiplicty; | ||
| 2556 | private final RealElements pReal; | ||
| 2557 | private final QualifiedNameElements pQualifiedName; | ||
| 2558 | private final TerminalRule tSTRING; | ||
| 2559 | private final TerminalRule tQUOTED_ID; | ||
| 2560 | private final TerminalRule tSL_COMMENT; | ||
| 2561 | private final TerminalRule tTRANSITIVE_CLOSURE; | ||
| 2562 | private final TerminalRule tREFLEXIVE_TRANSITIVE_CLOSURE; | ||
| 2563 | private final TerminalRule tFULL_STOP; | ||
| 2564 | private final NamedElementElements pNamedElement; | ||
| 1481 | 2565 | ||
| 1482 | private final Grammar grammar; | 2566 | private final Grammar grammar; |
| 1483 | 2567 | ||
| @@ -1490,49 +2574,73 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 1490 | this.gaTerminals = gaTerminals; | 2574 | this.gaTerminals = gaTerminals; |
| 1491 | this.pProblem = new ProblemElements(); | 2575 | this.pProblem = new ProblemElements(); |
| 1492 | this.pStatement = new StatementElements(); | 2576 | this.pStatement = new StatementElements(); |
| 1493 | this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | 2577 | this.pAssertionOrDefinition = new AssertionOrDefinitionElements(); |
| 1494 | this.pREALLiteral = new REALLiteralElements(); | 2578 | this.pPredicateDefinition = new PredicateDefinitionElements(); |
| 1495 | this.pINTLiteral = new INTLiteralElements(); | 2579 | this.pUnnamedErrorPrediateDefinition = new UnnamedErrorPrediateDefinitionElements(); |
| 1496 | this.pBooleanValue = new BooleanValueElements(); | 2580 | this.pDefaultDefinition = new DefaultDefinitionElements(); |
| 1497 | this.pTruthValue = new TruthValueElements(); | 2581 | this.pExternPredicateDefinition = new ExternPredicateDefinitionElements(); |
| 1498 | this.pInterpretation = new InterpretationElements(); | 2582 | this.eMetricType = new MetricTypeElements(); |
| 1499 | this.pBasicInterpretation = new BasicInterpretationElements(); | 2583 | this.pMetricDefinition = new MetricDefinitionElements(); |
| 1500 | this.pSymbol = new SymbolElements(); | 2584 | this.pExternMetricDefinition = new ExternMetricDefinitionElements(); |
| 1501 | this.pModelSymbol = new ModelSymbolElements(); | 2585 | this.pExpression = new ExpressionElements(); |
| 1502 | this.pPartialitySymbol = new PartialitySymbolElements(); | 2586 | this.pIfElse = new IfElseElements(); |
| 1503 | this.pExistSymbol = new ExistSymbolElements(); | 2587 | this.pDisjunctiveExpression = new DisjunctiveExpressionElements(); |
| 1504 | this.pEqualsSymbol = new EqualsSymbolElements(); | 2588 | this.pCase = new CaseElements(); |
| 1505 | this.pDataSymbol = new DataSymbolElements(); | 2589 | this.pConjunctiveExpression = new ConjunctiveExpressionElements(); |
| 1506 | this.pBooleanSymbol = new BooleanSymbolElements(); | 2590 | this.eBinaryOperator = new BinaryOperatorElements(); |
| 1507 | this.pIntegerSymbol = new IntegerSymbolElements(); | 2591 | this.eComparisonOperator = new ComparisonOperatorElements(); |
| 1508 | this.pRealSymbol = new RealSymbolElements(); | 2592 | this.pComparisonExpression = new ComparisonExpressionElements(); |
| 1509 | this.pStringSymbol = new StringSymbolElements(); | 2593 | this.eAdditiveBinaryOperator = new AdditiveBinaryOperatorElements(); |
| 1510 | this.pComplexObject = new ComplexObjectElements(); | 2594 | this.pAdditiveExpression = new AdditiveExpressionElements(); |
| 1511 | this.pObject = new ObjectElements(); | 2595 | this.eMultiplicativeBinaryOperator = new MultiplicativeBinaryOperatorElements(); |
| 1512 | this.pNamedObject = new NamedObjectElements(); | 2596 | this.pMultiplicativeExpression = new MultiplicativeExpressionElements(); |
| 1513 | this.pUnnamedObject = new UnnamedObjectElements(); | 2597 | this.eExponentialOp = new ExponentialOpElements(); |
| 1514 | this.pDataObject = new DataObjectElements(); | 2598 | this.pExponentialExpression = new ExponentialExpressionElements(); |
| 1515 | this.pBooleanObject = new BooleanObjectElements(); | 2599 | this.eUnaryOp = new UnaryOpElements(); |
| 1516 | this.pIntObject = new IntObjectElements(); | 2600 | this.pUnaryExpression = new UnaryExpressionElements(); |
| 1517 | this.pRealObject = new RealObjectElements(); | 2601 | this.pAggregationExpression = new AggregationExpressionElements(); |
| 1518 | this.pStringObject = new StringObjectElements(); | 2602 | this.pCount = new CountElements(); |
| 1519 | this.pPredicate = new PredicateElements(); | 2603 | this.eAggregationOp = new AggregationOpElements(); |
| 1520 | this.pParameter = new ParameterElements(); | 2604 | this.pAggregation = new AggregationElements(); |
| 1521 | this.pPatternBody = new PatternBodyElements(); | 2605 | this.pAtomicExpression = new AtomicExpressionElements(); |
| 1522 | this.pPolarity = new PolarityElements(); | 2606 | this.pCall = new CallElements(); |
| 1523 | this.pConstraint = new ConstraintElements(); | 2607 | this.pArgumentList = new ArgumentListElements(); |
| 1524 | this.pClosureType = new ClosureTypeElements(); | 2608 | this.pArgument = new ArgumentElements(); |
| 2609 | this.pExpressionArgument = new ExpressionArgumentElements(); | ||
| 2610 | this.pStarArgument = new StarArgumentElements(); | ||
| 2611 | this.pTypedArgument = new TypedArgumentElements(); | ||
| 2612 | this.pTypedStarArgument = new TypedStarArgumentElements(); | ||
| 2613 | this.pReference = new ReferenceElements(); | ||
| 2614 | this.pInterval = new IntervalElements(); | ||
| 1525 | this.pLiteral = new LiteralElements(); | 2615 | this.pLiteral = new LiteralElements(); |
| 1526 | this.pVariable = new VariableElements(); | 2616 | this.eLogicValue = new LogicValueElements(); |
| 1527 | this.pAllInstances = new AllInstancesElements(); | 2617 | this.pLogicLiteral = new LogicLiteralElements(); |
| 1528 | this.pAllObjects = new AllObjectsElements(); | 2618 | this.pNumericLiteral = new NumericLiteralElements(); |
| 1529 | this.pDefaultInterpretation = new DefaultInterpretationElements(); | 2619 | this.pInfinityLiteral = new InfinityLiteralElements(); |
| 1530 | this.pCDInterpretation = new CDInterpretationElements(); | 2620 | this.pEmptyIntervalLiteral = new EmptyIntervalLiteralElements(); |
| 1531 | this.pClassInterpretation = new ClassInterpretationElements(); | 2621 | this.pStringLiteral = new StringLiteralElements(); |
| 1532 | this.pEnumInterpretation = new EnumInterpretationElements(); | 2622 | this.pClassDefinition = new ClassDefinitionElements(); |
| 1533 | this.pFieldRelationInterpretation = new FieldRelationInterpretationElements(); | 2623 | this.pMemberDefinition = new MemberDefinitionElements(); |
| 1534 | this.pGlobalRelationInterpretation = new GlobalRelationInterpretationElements(); | 2624 | this.pMultiplicity = new MultiplicityElements(); |
| 1535 | this.pMultiplicityDefinition = new MultiplicityDefinitionElements(); | 2625 | this.pManyMultiplicity = new ManyMultiplicityElements(); |
| 2626 | this.pExactMultiplicity = new ExactMultiplicityElements(); | ||
| 2627 | this.pBoundedMultiplicity = new BoundedMultiplicityElements(); | ||
| 2628 | this.pScopeDefinition = new ScopeDefinitionElements(); | ||
| 2629 | this.pExactScopeDefinition = new ExactScopeDefinitionElements(); | ||
| 2630 | this.pBoundedScopeDefinition = new BoundedScopeDefinitionElements(); | ||
| 2631 | this.pLowerBoundedScopeDefinition = new LowerBoundedScopeDefinitionElements(); | ||
| 2632 | this.eObjectiveKind = new ObjectiveKindElements(); | ||
| 2633 | this.pObjectiveDefinition = new ObjectiveDefinitionElements(); | ||
| 2634 | this.pUpperMultiplicty = new UpperMultiplictyElements(); | ||
| 2635 | this.pReal = new RealElements(); | ||
| 2636 | this.pQualifiedName = new QualifiedNameElements(); | ||
| 2637 | this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
| 2638 | this.tQUOTED_ID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.QUOTED_ID"); | ||
| 2639 | this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.SL_COMMENT"); | ||
| 2640 | this.tTRANSITIVE_CLOSURE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
| 2641 | this.tREFLEXIVE_TRANSITIVE_CLOSURE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
| 2642 | this.tFULL_STOP = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FULL_STOP"); | ||
| 2643 | this.pNamedElement = new NamedElementElements(); | ||
| 1536 | } | 2644 | } |
| 1537 | 2645 | ||
| 1538 | protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { | 2646 | protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { |
| @@ -1573,7 +2681,9 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 1573 | } | 2681 | } |
| 1574 | 2682 | ||
| 1575 | //Statement: | 2683 | //Statement: |
| 1576 | // Interpretation | Predicate; | 2684 | // (AssertionOrDefinition | PredicateDefinition | UnnamedErrorPrediateDefinition | DefaultDefinition | |
| 2685 | // ExternPredicateDefinition | MetricDefinition | ExternMetricDefinition | ClassDefinition | ScopeDefinition | | ||
| 2686 | // ObjectiveDefinition) FULL_STOP; | ||
| 1577 | public StatementElements getStatementAccess() { | 2687 | public StatementElements getStatementAccess() { |
| 1578 | return pStatement; | 2688 | return pStatement; |
| 1579 | } | 2689 | } |
| @@ -1582,333 +2692,391 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 1582 | return getStatementAccess().getRule(); | 2692 | return getStatementAccess().getRule(); |
| 1583 | } | 2693 | } |
| 1584 | 2694 | ||
| 1585 | //@Override | 2695 | //AssertionOrDefinition Statement: |
| 1586 | //terminal STRING: | 2696 | // Expression ({Assertion.body=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" |
| 1587 | // '"' ('\\' . | !('\\' | '"'))* '"'; | 2697 | // body=Expression | {MetricDefinition.head=current} "=" body=Expression); |
| 1588 | public TerminalRule getSTRINGRule() { | 2698 | public AssertionOrDefinitionElements getAssertionOrDefinitionAccess() { |
| 1589 | return tSTRING; | 2699 | return pAssertionOrDefinition; |
| 1590 | } | 2700 | } |
| 1591 | 2701 | ||
| 1592 | //REALLiteral ecore::EBigDecimal: | 2702 | public ParserRule getAssertionOrDefinitionRule() { |
| 1593 | // '-'? INT '.' INT; | 2703 | return getAssertionOrDefinitionAccess().getRule(); |
| 1594 | public REALLiteralElements getREALLiteralAccess() { | ||
| 1595 | return pREALLiteral; | ||
| 1596 | } | 2704 | } |
| 1597 | 2705 | ||
| 1598 | public ParserRule getREALLiteralRule() { | 2706 | //PredicateDefinition: |
| 1599 | return getREALLiteralAccess().getRule(); | 2707 | // (functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression; |
| 2708 | public PredicateDefinitionElements getPredicateDefinitionAccess() { | ||
| 2709 | return pPredicateDefinition; | ||
| 1600 | } | 2710 | } |
| 1601 | 2711 | ||
| 1602 | //INTLiteral ecore::EInt: | 2712 | public ParserRule getPredicateDefinitionRule() { |
| 1603 | // '-'? INT; | 2713 | return getPredicateDefinitionAccess().getRule(); |
| 1604 | public INTLiteralElements getINTLiteralAccess() { | ||
| 1605 | return pINTLiteral; | ||
| 1606 | } | 2714 | } |
| 1607 | 2715 | ||
| 1608 | public ParserRule getINTLiteralRule() { | 2716 | //UnnamedErrorPrediateDefinition: |
| 1609 | return getINTLiteralAccess().getRule(); | 2717 | // "error" argumentList=ArgumentList ":-" body=Expression; |
| 2718 | public UnnamedErrorPrediateDefinitionElements getUnnamedErrorPrediateDefinitionAccess() { | ||
| 2719 | return pUnnamedErrorPrediateDefinition; | ||
| 1610 | } | 2720 | } |
| 1611 | 2721 | ||
| 1612 | //BooleanValue: | 2722 | public ParserRule getUnnamedErrorPrediateDefinitionRule() { |
| 1613 | // {BooleanTrue} 'true' | 'false' {BooleanFalse}; | 2723 | return getUnnamedErrorPrediateDefinitionAccess().getRule(); |
| 1614 | public BooleanValueElements getBooleanValueAccess() { | ||
| 1615 | return pBooleanValue; | ||
| 1616 | } | 2724 | } |
| 1617 | 2725 | ||
| 1618 | public ParserRule getBooleanValueRule() { | 2726 | //DefaultDefinition: |
| 1619 | return getBooleanValueAccess().getRule(); | 2727 | // "default" head=Call ":" range=Expression; |
| 2728 | public DefaultDefinitionElements getDefaultDefinitionAccess() { | ||
| 2729 | return pDefaultDefinition; | ||
| 1620 | } | 2730 | } |
| 1621 | 2731 | ||
| 1622 | //TruthValue: | 2732 | public ParserRule getDefaultDefinitionRule() { |
| 1623 | // {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error'; | 2733 | return getDefaultDefinitionAccess().getRule(); |
| 1624 | public TruthValueElements getTruthValueAccess() { | ||
| 1625 | return pTruthValue; | ||
| 1626 | } | 2734 | } |
| 1627 | 2735 | ||
| 1628 | public ParserRule getTruthValueRule() { | 2736 | //ExternPredicateDefinition: |
| 1629 | return getTruthValueAccess().getRule(); | 2737 | // "extern" head=Call; |
| 2738 | public ExternPredicateDefinitionElements getExternPredicateDefinitionAccess() { | ||
| 2739 | return pExternPredicateDefinition; | ||
| 1630 | } | 2740 | } |
| 1631 | 2741 | ||
| 1632 | ///////////////////// | 2742 | public ParserRule getExternPredicateDefinitionRule() { |
| 1633 | //// Core grammar | 2743 | return getExternPredicateDefinitionAccess().getRule(); |
| 1634 | // /////////////////// | ||
| 1635 | //Interpretation: | ||
| 1636 | // BasicInterpretation | DefaultInterpretation | CDInterpretation; | ||
| 1637 | public InterpretationElements getInterpretationAccess() { | ||
| 1638 | return pInterpretation; | ||
| 1639 | } | 2744 | } |
| 1640 | 2745 | ||
| 1641 | public ParserRule getInterpretationRule() { | 2746 | //enum MetricType: |
| 1642 | return getInterpretationAccess().getRule(); | 2747 | // INT="int" | REAL="real"; |
| 2748 | public MetricTypeElements getMetricTypeAccess() { | ||
| 2749 | return eMetricType; | ||
| 1643 | } | 2750 | } |
| 1644 | 2751 | ||
| 1645 | //BasicInterpretation: | 2752 | public EnumRule getMetricTypeRule() { |
| 1646 | // symbol=Symbol ('(' (objects+=ComplexObject (',' objects+=ComplexObject)*)? ')')? ':' value=TruthValue; | 2753 | return getMetricTypeAccess().getRule(); |
| 1647 | public BasicInterpretationElements getBasicInterpretationAccess() { | ||
| 1648 | return pBasicInterpretation; | ||
| 1649 | } | 2754 | } |
| 1650 | 2755 | ||
| 1651 | public ParserRule getBasicInterpretationRule() { | 2756 | //MetricDefinition: |
| 1652 | return getBasicInterpretationAccess().getRule(); | 2757 | // type=MetricType head=Expression "=" body=Expression; |
| 2758 | public MetricDefinitionElements getMetricDefinitionAccess() { | ||
| 2759 | return pMetricDefinition; | ||
| 1653 | } | 2760 | } |
| 1654 | 2761 | ||
| 1655 | //Symbol: | 2762 | public ParserRule getMetricDefinitionRule() { |
| 1656 | // ModelSymbol | PartialitySymbol | DataSymbol; | 2763 | return getMetricDefinitionAccess().getRule(); |
| 1657 | public SymbolElements getSymbolAccess() { | ||
| 1658 | return pSymbol; | ||
| 1659 | } | 2764 | } |
| 1660 | 2765 | ||
| 1661 | public ParserRule getSymbolRule() { | 2766 | //ExternMetricDefinition: |
| 1662 | return getSymbolAccess().getRule(); | 2767 | // "extern" type=MetricType head=Call; |
| 2768 | public ExternMetricDefinitionElements getExternMetricDefinitionAccess() { | ||
| 2769 | return pExternMetricDefinition; | ||
| 1663 | } | 2770 | } |
| 1664 | 2771 | ||
| 1665 | //ModelSymbol: | 2772 | public ParserRule getExternMetricDefinitionRule() { |
| 1666 | // name=ID; | 2773 | return getExternMetricDefinitionAccess().getRule(); |
| 1667 | public ModelSymbolElements getModelSymbolAccess() { | ||
| 1668 | return pModelSymbol; | ||
| 1669 | } | 2774 | } |
| 1670 | 2775 | ||
| 1671 | public ParserRule getModelSymbolRule() { | 2776 | //Expression: |
| 1672 | return getModelSymbolAccess().getRule(); | 2777 | // IfElse | DisjunctiveExpression; |
| 2778 | public ExpressionElements getExpressionAccess() { | ||
| 2779 | return pExpression; | ||
| 1673 | } | 2780 | } |
| 1674 | 2781 | ||
| 1675 | //PartialitySymbol: | 2782 | public ParserRule getExpressionRule() { |
| 1676 | // ExistSymbol | EqualsSymbol; | 2783 | return getExpressionAccess().getRule(); |
| 1677 | public PartialitySymbolElements getPartialitySymbolAccess() { | ||
| 1678 | return pPartialitySymbol; | ||
| 1679 | } | 2784 | } |
| 1680 | 2785 | ||
| 1681 | public ParserRule getPartialitySymbolRule() { | 2786 | //IfElse: |
| 1682 | return getPartialitySymbolAccess().getRule(); | 2787 | // "if" condition=Expression "then" then=Expression "else" else=Expression; |
| 2788 | public IfElseElements getIfElseAccess() { | ||
| 2789 | return pIfElse; | ||
| 1683 | } | 2790 | } |
| 1684 | 2791 | ||
| 1685 | //ExistSymbol: | 2792 | public ParserRule getIfElseRule() { |
| 1686 | // 'exists' {ExistSymbol}; | 2793 | return getIfElseAccess().getRule(); |
| 1687 | public ExistSymbolElements getExistSymbolAccess() { | ||
| 1688 | return pExistSymbol; | ||
| 1689 | } | 2794 | } |
| 1690 | 2795 | ||
| 1691 | public ParserRule getExistSymbolRule() { | 2796 | //DisjunctiveExpression Expression: |
| 1692 | return getExistSymbolAccess().getRule(); | 2797 | // ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | |
| 2798 | // {Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)?; | ||
| 2799 | public DisjunctiveExpressionElements getDisjunctiveExpressionAccess() { | ||
| 2800 | return pDisjunctiveExpression; | ||
| 1693 | } | 2801 | } |
| 1694 | 2802 | ||
| 1695 | //EqualsSymbol: | 2803 | public ParserRule getDisjunctiveExpressionRule() { |
| 1696 | // 'equals' {EqualsSymbol}; | 2804 | return getDisjunctiveExpressionAccess().getRule(); |
| 1697 | public EqualsSymbolElements getEqualsSymbolAccess() { | ||
| 1698 | return pEqualsSymbol; | ||
| 1699 | } | 2805 | } |
| 1700 | 2806 | ||
| 1701 | public ParserRule getEqualsSymbolRule() { | 2807 | //Case: |
| 1702 | return getEqualsSymbolAccess().getRule(); | 2808 | // condition=ConjunctiveExpression "->" body=ConjunctiveExpression; |
| 2809 | public CaseElements getCaseAccess() { | ||
| 2810 | return pCase; | ||
| 1703 | } | 2811 | } |
| 1704 | 2812 | ||
| 1705 | //DataSymbol: | 2813 | public ParserRule getCaseRule() { |
| 1706 | // BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol; | 2814 | return getCaseAccess().getRule(); |
| 1707 | public DataSymbolElements getDataSymbolAccess() { | ||
| 1708 | return pDataSymbol; | ||
| 1709 | } | 2815 | } |
| 1710 | 2816 | ||
| 1711 | public ParserRule getDataSymbolRule() { | 2817 | //ConjunctiveExpression Expression: |
| 1712 | return getDataSymbolAccess().getRule(); | 2818 | // ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)?; |
| 2819 | public ConjunctiveExpressionElements getConjunctiveExpressionAccess() { | ||
| 2820 | return pConjunctiveExpression; | ||
| 1713 | } | 2821 | } |
| 1714 | 2822 | ||
| 1715 | //BooleanSymbol: | 2823 | public ParserRule getConjunctiveExpressionRule() { |
| 1716 | // 'bool' {BooleanSymbol}; | 2824 | return getConjunctiveExpressionAccess().getRule(); |
| 1717 | public BooleanSymbolElements getBooleanSymbolAccess() { | ||
| 1718 | return pBooleanSymbol; | ||
| 1719 | } | 2825 | } |
| 1720 | 2826 | ||
| 1721 | public ParserRule getBooleanSymbolRule() { | 2827 | //enum BinaryOperator: |
| 1722 | return getBooleanSymbolAccess().getRule(); | 2828 | // EQ | NOT_EQ | LESS | LESS_EQ | GREATER | GREATER_EQ | IN | ADD | SUB | MUL | DIV | POW; |
| 2829 | public BinaryOperatorElements getBinaryOperatorAccess() { | ||
| 2830 | return eBinaryOperator; | ||
| 1723 | } | 2831 | } |
| 1724 | 2832 | ||
| 1725 | //IntegerSymbol: | 2833 | public EnumRule getBinaryOperatorRule() { |
| 1726 | // 'int' {IntegerSymbol}; | 2834 | return getBinaryOperatorAccess().getRule(); |
| 1727 | public IntegerSymbolElements getIntegerSymbolAccess() { | ||
| 1728 | return pIntegerSymbol; | ||
| 1729 | } | 2835 | } |
| 1730 | 2836 | ||
| 1731 | public ParserRule getIntegerSymbolRule() { | 2837 | //enum ComparisonOperator returns BinaryOperator: |
| 1732 | return getIntegerSymbolAccess().getRule(); | 2838 | // EQ="==" | NOT_EQ="!=" | LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | IN="in"; |
| 2839 | public ComparisonOperatorElements getComparisonOperatorAccess() { | ||
| 2840 | return eComparisonOperator; | ||
| 1733 | } | 2841 | } |
| 1734 | 2842 | ||
| 1735 | //RealSymbol: | 2843 | public EnumRule getComparisonOperatorRule() { |
| 1736 | // 'real' {RealSymbol}; | 2844 | return getComparisonOperatorAccess().getRule(); |
| 1737 | public RealSymbolElements getRealSymbolAccess() { | ||
| 1738 | return pRealSymbol; | ||
| 1739 | } | 2845 | } |
| 1740 | 2846 | ||
| 1741 | public ParserRule getRealSymbolRule() { | 2847 | //ComparisonExpression Expression: |
| 1742 | return getRealSymbolAccess().getRule(); | 2848 | // AdditiveExpression ({Comparison.left=current} op=ComparisonOperator right=AdditiveExpression)?; |
| 2849 | public ComparisonExpressionElements getComparisonExpressionAccess() { | ||
| 2850 | return pComparisonExpression; | ||
| 1743 | } | 2851 | } |
| 1744 | 2852 | ||
| 1745 | //StringSymbol: | 2853 | public ParserRule getComparisonExpressionRule() { |
| 1746 | // 'string' {StringSymbol}; | 2854 | return getComparisonExpressionAccess().getRule(); |
| 1747 | public StringSymbolElements getStringSymbolAccess() { | ||
| 1748 | return pStringSymbol; | ||
| 1749 | } | 2855 | } |
| 1750 | 2856 | ||
| 1751 | public ParserRule getStringSymbolRule() { | 2857 | //enum AdditiveBinaryOperator returns BinaryOperator: |
| 1752 | return getStringSymbolAccess().getRule(); | 2858 | // ADD="+" | SUB="-"; |
| 2859 | public AdditiveBinaryOperatorElements getAdditiveBinaryOperatorAccess() { | ||
| 2860 | return eAdditiveBinaryOperator; | ||
| 1753 | } | 2861 | } |
| 1754 | 2862 | ||
| 1755 | //ComplexObject: | 2863 | public EnumRule getAdditiveBinaryOperatorRule() { |
| 1756 | // Object | AllInstances | AllObjects; | 2864 | return getAdditiveBinaryOperatorAccess().getRule(); |
| 1757 | public ComplexObjectElements getComplexObjectAccess() { | ||
| 1758 | return pComplexObject; | ||
| 1759 | } | 2865 | } |
| 1760 | 2866 | ||
| 1761 | public ParserRule getComplexObjectRule() { | 2867 | //AdditiveExpression Expression: |
| 1762 | return getComplexObjectAccess().getRule(); | 2868 | // MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)*; |
| 2869 | public AdditiveExpressionElements getAdditiveExpressionAccess() { | ||
| 2870 | return pAdditiveExpression; | ||
| 1763 | } | 2871 | } |
| 1764 | 2872 | ||
| 1765 | //Object: | 2873 | public ParserRule getAdditiveExpressionRule() { |
| 1766 | // NamedObject | UnnamedObject | DataObject; | 2874 | return getAdditiveExpressionAccess().getRule(); |
| 1767 | public ObjectElements getObjectAccess() { | ||
| 1768 | return pObject; | ||
| 1769 | } | 2875 | } |
| 1770 | 2876 | ||
| 1771 | public ParserRule getObjectRule() { | 2877 | //enum MultiplicativeBinaryOperator returns BinaryOperator: |
| 1772 | return getObjectAccess().getRule(); | 2878 | // MUL="*" | DIV="/"; |
| 2879 | public MultiplicativeBinaryOperatorElements getMultiplicativeBinaryOperatorAccess() { | ||
| 2880 | return eMultiplicativeBinaryOperator; | ||
| 1773 | } | 2881 | } |
| 1774 | 2882 | ||
| 1775 | //NamedObject: | 2883 | public EnumRule getMultiplicativeBinaryOperatorRule() { |
| 1776 | // "'" name=ID "'"; | 2884 | return getMultiplicativeBinaryOperatorAccess().getRule(); |
| 1777 | public NamedObjectElements getNamedObjectAccess() { | ||
| 1778 | return pNamedObject; | ||
| 1779 | } | 2885 | } |
| 1780 | 2886 | ||
| 1781 | public ParserRule getNamedObjectRule() { | 2887 | //MultiplicativeExpression Expression: |
| 1782 | return getNamedObjectAccess().getRule(); | 2888 | // ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)*; |
| 2889 | public MultiplicativeExpressionElements getMultiplicativeExpressionAccess() { | ||
| 2890 | return pMultiplicativeExpression; | ||
| 1783 | } | 2891 | } |
| 1784 | 2892 | ||
| 1785 | //UnnamedObject: | 2893 | public ParserRule getMultiplicativeExpressionRule() { |
| 1786 | // name=ID; | 2894 | return getMultiplicativeExpressionAccess().getRule(); |
| 1787 | public UnnamedObjectElements getUnnamedObjectAccess() { | ||
| 1788 | return pUnnamedObject; | ||
| 1789 | } | 2895 | } |
| 1790 | 2896 | ||
| 1791 | public ParserRule getUnnamedObjectRule() { | 2897 | //enum ExponentialOp returns BinaryOperator: |
| 1792 | return getUnnamedObjectAccess().getRule(); | 2898 | // POW="^"; |
| 2899 | public ExponentialOpElements getExponentialOpAccess() { | ||
| 2900 | return eExponentialOp; | ||
| 1793 | } | 2901 | } |
| 1794 | 2902 | ||
| 1795 | //DataObject: | 2903 | public EnumRule getExponentialOpRule() { |
| 1796 | // BooleanObject | IntObject | RealObject | StringObject; | 2904 | return getExponentialOpAccess().getRule(); |
| 1797 | public DataObjectElements getDataObjectAccess() { | ||
| 1798 | return pDataObject; | ||
| 1799 | } | 2905 | } |
| 1800 | 2906 | ||
| 1801 | public ParserRule getDataObjectRule() { | 2907 | //ExponentialExpression Expression: |
| 1802 | return getDataObjectAccess().getRule(); | 2908 | // UnaryExpression ({BinaryExpression.left=current} op=ExponentialOp right=ExponentialExpression)?; |
| 2909 | public ExponentialExpressionElements getExponentialExpressionAccess() { | ||
| 2910 | return pExponentialExpression; | ||
| 1803 | } | 2911 | } |
| 1804 | 2912 | ||
| 1805 | //BooleanObject: | 2913 | public ParserRule getExponentialExpressionRule() { |
| 1806 | // value=BooleanValue; | 2914 | return getExponentialExpressionAccess().getRule(); |
| 1807 | public BooleanObjectElements getBooleanObjectAccess() { | ||
| 1808 | return pBooleanObject; | ||
| 1809 | } | 2915 | } |
| 1810 | 2916 | ||
| 1811 | public ParserRule getBooleanObjectRule() { | 2917 | //enum UnaryOp: |
| 1812 | return getBooleanObjectAccess().getRule(); | 2918 | // NEG="!" | PLUS="+" | MINUS="-" | MAY="may" | MUST="must" | CURRENT="current"; |
| 2919 | public UnaryOpElements getUnaryOpAccess() { | ||
| 2920 | return eUnaryOp; | ||
| 1813 | } | 2921 | } |
| 1814 | 2922 | ||
| 1815 | //IntObject: | 2923 | public EnumRule getUnaryOpRule() { |
| 1816 | // value=INTLiteral; | 2924 | return getUnaryOpAccess().getRule(); |
| 1817 | public IntObjectElements getIntObjectAccess() { | ||
| 1818 | return pIntObject; | ||
| 1819 | } | 2925 | } |
| 1820 | 2926 | ||
| 1821 | public ParserRule getIntObjectRule() { | 2927 | //UnaryExpression Expression: |
| 1822 | return getIntObjectAccess().getRule(); | 2928 | // AggregationExpression | {UnaryExpression} op=UnaryOp body=AggregationExpression; |
| 2929 | public UnaryExpressionElements getUnaryExpressionAccess() { | ||
| 2930 | return pUnaryExpression; | ||
| 1823 | } | 2931 | } |
| 1824 | 2932 | ||
| 1825 | //RealObject: | 2933 | public ParserRule getUnaryExpressionRule() { |
| 1826 | // value=REALLiteral; | 2934 | return getUnaryExpressionAccess().getRule(); |
| 1827 | public RealObjectElements getRealObjectAccess() { | ||
| 1828 | return pRealObject; | ||
| 1829 | } | 2935 | } |
| 1830 | 2936 | ||
| 1831 | public ParserRule getRealObjectRule() { | 2937 | //AggregationExpression Expression: |
| 1832 | return getRealObjectAccess().getRule(); | 2938 | // AtomicExpression | Count | Aggregation; |
| 2939 | public AggregationExpressionElements getAggregationExpressionAccess() { | ||
| 2940 | return pAggregationExpression; | ||
| 1833 | } | 2941 | } |
| 1834 | 2942 | ||
| 1835 | //StringObject: | 2943 | public ParserRule getAggregationExpressionRule() { |
| 1836 | // value=STRING; | 2944 | return getAggregationExpressionAccess().getRule(); |
| 1837 | public StringObjectElements getStringObjectAccess() { | 2945 | } |
| 1838 | return pStringObject; | 2946 | |
| 2947 | //Count: | ||
| 2948 | // "count" "{" body=Expression "}"; | ||
| 2949 | public CountElements getCountAccess() { | ||
| 2950 | return pCount; | ||
| 2951 | } | ||
| 2952 | |||
| 2953 | public ParserRule getCountRule() { | ||
| 2954 | return getCountAccess().getRule(); | ||
| 2955 | } | ||
| 2956 | |||
| 2957 | //enum AggregationOp: | ||
| 2958 | // ONLY="only" | SUM="sum" | PROD="prod" | AVG="avg" | MIN="min" | MAX="max"; | ||
| 2959 | public AggregationOpElements getAggregationOpAccess() { | ||
| 2960 | return eAggregationOp; | ||
| 2961 | } | ||
| 2962 | |||
| 2963 | public EnumRule getAggregationOpRule() { | ||
| 2964 | return getAggregationOpAccess().getRule(); | ||
| 2965 | } | ||
| 2966 | |||
| 2967 | //Aggregation: | ||
| 2968 | // op=AggregationOp "{" body=Expression "|" condition=Expression "}"; | ||
| 2969 | public AggregationElements getAggregationAccess() { | ||
| 2970 | return pAggregation; | ||
| 2971 | } | ||
| 2972 | |||
| 2973 | public ParserRule getAggregationRule() { | ||
| 2974 | return getAggregationAccess().getRule(); | ||
| 2975 | } | ||
| 2976 | |||
| 2977 | //AtomicExpression Expression: | ||
| 2978 | // Reference | Call | Interval | Literal | "(" Expression ")"; | ||
| 2979 | public AtomicExpressionElements getAtomicExpressionAccess() { | ||
| 2980 | return pAtomicExpression; | ||
| 2981 | } | ||
| 2982 | |||
| 2983 | public ParserRule getAtomicExpressionRule() { | ||
| 2984 | return getAtomicExpressionAccess().getRule(); | ||
| 1839 | } | 2985 | } |
| 1840 | 2986 | ||
| 1841 | public ParserRule getStringObjectRule() { | 2987 | //Call: |
| 1842 | return getStringObjectAccess().getRule(); | 2988 | // functor=Reference (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? |
| 2989 | // argumentList=ArgumentList; | ||
| 2990 | public CallElements getCallAccess() { | ||
| 2991 | return pCall; | ||
| 1843 | } | 2992 | } |
| 1844 | 2993 | ||
| 1845 | ///////////////////// | 2994 | public ParserRule getCallRule() { |
| 1846 | //// Predicte grammar | 2995 | return getCallAccess().getRule(); |
| 1847 | ///////////////////// | ||
| 1848 | //Predicate: | ||
| 1849 | // isError?='error'? symbol=ModelSymbol ('(' (parameters+=Parameter (',' parameters+=Parameter)*)? ')')? ':-' ('false' | | ||
| 1850 | // bodies+=PatternBody ('|' bodies+=PatternBody)*) '.'; | ||
| 1851 | public PredicateElements getPredicateAccess() { | ||
| 1852 | return pPredicate; | ||
| 1853 | } | 2996 | } |
| 1854 | 2997 | ||
| 1855 | public ParserRule getPredicateRule() { | 2998 | //ArgumentList: |
| 1856 | return getPredicateAccess().getRule(); | 2999 | // {ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; |
| 3000 | public ArgumentListElements getArgumentListAccess() { | ||
| 3001 | return pArgumentList; | ||
| 1857 | } | 3002 | } |
| 1858 | 3003 | ||
| 1859 | //Parameter: | 3004 | public ParserRule getArgumentListRule() { |
| 1860 | // variable=Variable (':' type=Symbol)?; | 3005 | return getArgumentListAccess().getRule(); |
| 1861 | public ParameterElements getParameterAccess() { | ||
| 1862 | return pParameter; | ||
| 1863 | } | 3006 | } |
| 1864 | 3007 | ||
| 1865 | public ParserRule getParameterRule() { | 3008 | //Argument: |
| 1866 | return getParameterAccess().getRule(); | 3009 | // ExpressionArgument | StarArgument | TypedArgument | TypedStarArgument; |
| 3010 | public ArgumentElements getArgumentAccess() { | ||
| 3011 | return pArgument; | ||
| 1867 | } | 3012 | } |
| 1868 | 3013 | ||
| 1869 | //PatternBody: | 3014 | public ParserRule getArgumentRule() { |
| 1870 | // {PatternBody} ('true' | constraints+=Constraint*); | 3015 | return getArgumentAccess().getRule(); |
| 1871 | public PatternBodyElements getPatternBodyAccess() { | ||
| 1872 | return pPatternBody; | ||
| 1873 | } | 3016 | } |
| 1874 | 3017 | ||
| 1875 | public ParserRule getPatternBodyRule() { | 3018 | //ExpressionArgument: |
| 1876 | return getPatternBodyAccess().getRule(); | 3019 | // body=ComparisonExpression; |
| 3020 | public ExpressionArgumentElements getExpressionArgumentAccess() { | ||
| 3021 | return pExpressionArgument; | ||
| 1877 | } | 3022 | } |
| 1878 | 3023 | ||
| 1879 | //Polarity: | 3024 | public ParserRule getExpressionArgumentRule() { |
| 1880 | // {Positive} '+' | {Negative} '-'; | 3025 | return getExpressionArgumentAccess().getRule(); |
| 1881 | public PolarityElements getPolarityAccess() { | ||
| 1882 | return pPolarity; | ||
| 1883 | } | 3026 | } |
| 1884 | 3027 | ||
| 1885 | public ParserRule getPolarityRule() { | 3028 | //StarArgument: |
| 1886 | return getPolarityAccess().getRule(); | 3029 | // {StarArgument} "*"; |
| 3030 | public StarArgumentElements getStarArgumentAccess() { | ||
| 3031 | return pStarArgument; | ||
| 1887 | } | 3032 | } |
| 1888 | 3033 | ||
| 1889 | //Constraint: | 3034 | public ParserRule getStarArgumentRule() { |
| 1890 | // polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal? (',' params+=Literal)* ')')? | closureType=ClosureType | 3035 | return getStarArgumentAccess().getRule(); |
| 1891 | // '(' params+=Literal? (',' params+=Literal)* ')'; | ||
| 1892 | public ConstraintElements getConstraintAccess() { | ||
| 1893 | return pConstraint; | ||
| 1894 | } | 3036 | } |
| 1895 | 3037 | ||
| 1896 | public ParserRule getConstraintRule() { | 3038 | //TypedArgument: |
| 1897 | return getConstraintAccess().getRule(); | 3039 | // type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName]; |
| 3040 | public TypedArgumentElements getTypedArgumentAccess() { | ||
| 3041 | return pTypedArgument; | ||
| 1898 | } | 3042 | } |
| 1899 | 3043 | ||
| 1900 | //ClosureType: | 3044 | public ParserRule getTypedArgumentRule() { |
| 1901 | // {ReflexiveClosure} '*' | {IrreflexiveClosure} '+'; | 3045 | return getTypedArgumentAccess().getRule(); |
| 1902 | public ClosureTypeElements getClosureTypeAccess() { | ||
| 1903 | return pClosureType; | ||
| 1904 | } | 3046 | } |
| 1905 | 3047 | ||
| 1906 | public ParserRule getClosureTypeRule() { | 3048 | //TypedStarArgument: |
| 1907 | return getClosureTypeAccess().getRule(); | 3049 | // type=[NamedElement|QualifiedName] "*"; |
| 3050 | public TypedStarArgumentElements getTypedStarArgumentAccess() { | ||
| 3051 | return pTypedStarArgument; | ||
| 3052 | } | ||
| 3053 | |||
| 3054 | public ParserRule getTypedStarArgumentRule() { | ||
| 3055 | return getTypedStarArgumentAccess().getRule(); | ||
| 3056 | } | ||
| 3057 | |||
| 3058 | //Reference: | ||
| 3059 | // referred=[NamedElement|QualifiedName]; | ||
| 3060 | public ReferenceElements getReferenceAccess() { | ||
| 3061 | return pReference; | ||
| 3062 | } | ||
| 3063 | |||
| 3064 | public ParserRule getReferenceRule() { | ||
| 3065 | return getReferenceAccess().getRule(); | ||
| 3066 | } | ||
| 3067 | |||
| 3068 | //Interval: | ||
| 3069 | // "[" lowerBound=Expression ".." upperBound=Expression "]"; | ||
| 3070 | public IntervalElements getIntervalAccess() { | ||
| 3071 | return pInterval; | ||
| 3072 | } | ||
| 3073 | |||
| 3074 | public ParserRule getIntervalRule() { | ||
| 3075 | return getIntervalAccess().getRule(); | ||
| 1908 | } | 3076 | } |
| 1909 | 3077 | ||
| 1910 | //Literal: | 3078 | //Literal: |
| 1911 | // Variable | DataObject | NamedObject; | 3079 | // LogicLiteral | NumericLiteral | InfinityLiteral | EmptyIntervalLiteral | StringLiteral; |
| 1912 | public LiteralElements getLiteralAccess() { | 3080 | public LiteralElements getLiteralAccess() { |
| 1913 | return pLiteral; | 3081 | return pLiteral; |
| 1914 | } | 3082 | } |
| @@ -1917,116 +3085,267 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 1917 | return getLiteralAccess().getRule(); | 3085 | return getLiteralAccess().getRule(); |
| 1918 | } | 3086 | } |
| 1919 | 3087 | ||
| 1920 | //Variable: | 3088 | //enum LogicValue: |
| 1921 | // name=ID; | 3089 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error"; |
| 1922 | public VariableElements getVariableAccess() { | 3090 | public LogicValueElements getLogicValueAccess() { |
| 1923 | return pVariable; | 3091 | return eLogicValue; |
| 3092 | } | ||
| 3093 | |||
| 3094 | public EnumRule getLogicValueRule() { | ||
| 3095 | return getLogicValueAccess().getRule(); | ||
| 3096 | } | ||
| 3097 | |||
| 3098 | //LogicLiteral: | ||
| 3099 | // value=LogicValue; | ||
| 3100 | public LogicLiteralElements getLogicLiteralAccess() { | ||
| 3101 | return pLogicLiteral; | ||
| 3102 | } | ||
| 3103 | |||
| 3104 | public ParserRule getLogicLiteralRule() { | ||
| 3105 | return getLogicLiteralAccess().getRule(); | ||
| 3106 | } | ||
| 3107 | |||
| 3108 | //NumericLiteral: | ||
| 3109 | // value=Real; | ||
| 3110 | public NumericLiteralElements getNumericLiteralAccess() { | ||
| 3111 | return pNumericLiteral; | ||
| 3112 | } | ||
| 3113 | |||
| 3114 | public ParserRule getNumericLiteralRule() { | ||
| 3115 | return getNumericLiteralAccess().getRule(); | ||
| 3116 | } | ||
| 3117 | |||
| 3118 | //InfinityLiteral: | ||
| 3119 | // {InfinityLiteral} "inf"; | ||
| 3120 | public InfinityLiteralElements getInfinityLiteralAccess() { | ||
| 3121 | return pInfinityLiteral; | ||
| 3122 | } | ||
| 3123 | |||
| 3124 | public ParserRule getInfinityLiteralRule() { | ||
| 3125 | return getInfinityLiteralAccess().getRule(); | ||
| 1924 | } | 3126 | } |
| 1925 | 3127 | ||
| 1926 | public ParserRule getVariableRule() { | 3128 | //EmptyIntervalLiteral: |
| 1927 | return getVariableAccess().getRule(); | 3129 | // {EmptyIntervalLiteral} "empty"; |
| 3130 | public EmptyIntervalLiteralElements getEmptyIntervalLiteralAccess() { | ||
| 3131 | return pEmptyIntervalLiteral; | ||
| 1928 | } | 3132 | } |
| 1929 | 3133 | ||
| 1930 | ///////////////////// | 3134 | public ParserRule getEmptyIntervalLiteralRule() { |
| 1931 | //// Complex Interpretation grammar | 3135 | return getEmptyIntervalLiteralAccess().getRule(); |
| 1932 | ///////////////////// | 3136 | } |
| 1933 | //AllInstances: | 3137 | |
| 1934 | // ':' symbol=Symbol; | 3138 | //StringLiteral: |
| 1935 | public AllInstancesElements getAllInstancesAccess() { | 3139 | // value=STRING; |
| 1936 | return pAllInstances; | 3140 | public StringLiteralElements getStringLiteralAccess() { |
| 3141 | return pStringLiteral; | ||
| 1937 | } | 3142 | } |
| 1938 | 3143 | ||
| 1939 | public ParserRule getAllInstancesRule() { | 3144 | public ParserRule getStringLiteralRule() { |
| 1940 | return getAllInstancesAccess().getRule(); | 3145 | return getStringLiteralAccess().getRule(); |
| 1941 | } | 3146 | } |
| 1942 | 3147 | ||
| 1943 | //AllObjects: | 3148 | //ClassDefinition: |
| 1944 | // {AllObjects} '*'; | 3149 | // abstract?="abstract"? "class" name=ID ("extends" superclasses+=[NamedElement|QualifiedName] ("," |
| 1945 | public AllObjectsElements getAllObjectsAccess() { | 3150 | // superclasses+=[NamedElement|QualifiedName])*)? |
| 1946 | return pAllObjects; | 3151 | // "{" members+=MemberDefinition* "}"; |
| 3152 | public ClassDefinitionElements getClassDefinitionAccess() { | ||
| 3153 | return pClassDefinition; | ||
| 1947 | } | 3154 | } |
| 1948 | 3155 | ||
| 1949 | public ParserRule getAllObjectsRule() { | 3156 | public ParserRule getClassDefinitionRule() { |
| 1950 | return getAllObjectsAccess().getRule(); | 3157 | return getClassDefinitionAccess().getRule(); |
| 1951 | } | 3158 | } |
| 1952 | 3159 | ||
| 1953 | ///////////////////// | 3160 | //MemberDefinition: |
| 1954 | //// Defaul Interpretation grammar | 3161 | // containment?="contains"? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID ("opposite" |
| 1955 | ///////////////////// | 3162 | // opposite=[NamedElement|QualifiedName])? ";"?; |
| 1956 | //DefaultInterpretation: | 3163 | public MemberDefinitionElements getMemberDefinitionAccess() { |
| 1957 | // 'default' interpretation=BasicInterpretation; | 3164 | return pMemberDefinition; |
| 1958 | public DefaultInterpretationElements getDefaultInterpretationAccess() { | ||
| 1959 | return pDefaultInterpretation; | ||
| 1960 | } | 3165 | } |
| 1961 | 3166 | ||
| 1962 | public ParserRule getDefaultInterpretationRule() { | 3167 | public ParserRule getMemberDefinitionRule() { |
| 1963 | return getDefaultInterpretationAccess().getRule(); | 3168 | return getMemberDefinitionAccess().getRule(); |
| 1964 | } | 3169 | } |
| 1965 | 3170 | ||
| 1966 | ///////////////////// | 3171 | //Multiplicity: |
| 1967 | //// Advanced Class-Diagram interpretations | 3172 | // ManyMultiplicity | ExactMultiplicity | BoundedMultiplicity; |
| 1968 | ///////////////////// | 3173 | public MultiplicityElements getMultiplicityAccess() { |
| 1969 | //CDInterpretation: | 3174 | return pMultiplicity; |
| 1970 | // ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation; | ||
| 1971 | public CDInterpretationElements getCDInterpretationAccess() { | ||
| 1972 | return pCDInterpretation; | ||
| 1973 | } | 3175 | } |
| 1974 | 3176 | ||
| 1975 | public ParserRule getCDInterpretationRule() { | 3177 | public ParserRule getMultiplicityRule() { |
| 1976 | return getCDInterpretationAccess().getRule(); | 3178 | return getMultiplicityAccess().getRule(); |
| 1977 | } | 3179 | } |
| 1978 | 3180 | ||
| 1979 | //ClassInterpretation: | 3181 | //ManyMultiplicity: |
| 1980 | // abstract?='abstract'? 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' | 3182 | // {ManyMultiplicity} "[" "]"; |
| 1981 | // fielt+=FieldRelationInterpretation* | 3183 | public ManyMultiplicityElements getManyMultiplicityAccess() { |
| 1982 | // '}'; | 3184 | return pManyMultiplicity; |
| 1983 | public ClassInterpretationElements getClassInterpretationAccess() { | ||
| 1984 | return pClassInterpretation; | ||
| 1985 | } | 3185 | } |
| 1986 | 3186 | ||
| 1987 | public ParserRule getClassInterpretationRule() { | 3187 | public ParserRule getManyMultiplicityRule() { |
| 1988 | return getClassInterpretationAccess().getRule(); | 3188 | return getManyMultiplicityAccess().getRule(); |
| 1989 | } | 3189 | } |
| 1990 | 3190 | ||
| 1991 | //EnumInterpretation: | 3191 | //ExactMultiplicity: |
| 1992 | // 'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}'; | 3192 | // "[" multiplicity=UpperMultiplicty "]"; |
| 1993 | public EnumInterpretationElements getEnumInterpretationAccess() { | 3193 | public ExactMultiplicityElements getExactMultiplicityAccess() { |
| 1994 | return pEnumInterpretation; | 3194 | return pExactMultiplicity; |
| 1995 | } | 3195 | } |
| 1996 | 3196 | ||
| 1997 | public ParserRule getEnumInterpretationRule() { | 3197 | public ParserRule getExactMultiplicityRule() { |
| 1998 | return getEnumInterpretationAccess().getRule(); | 3198 | return getExactMultiplicityAccess().getRule(); |
| 1999 | } | 3199 | } |
| 2000 | 3200 | ||
| 2001 | //FieldRelationInterpretation: | 3201 | //BoundedMultiplicity: |
| 2002 | // containment?='containment'? symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol; | 3202 | // "[" lowerBound=INT ".." upperBound=UpperMultiplicty "]"; |
| 2003 | public FieldRelationInterpretationElements getFieldRelationInterpretationAccess() { | 3203 | public BoundedMultiplicityElements getBoundedMultiplicityAccess() { |
| 2004 | return pFieldRelationInterpretation; | 3204 | return pBoundedMultiplicity; |
| 2005 | } | 3205 | } |
| 2006 | 3206 | ||
| 2007 | public ParserRule getFieldRelationInterpretationRule() { | 3207 | public ParserRule getBoundedMultiplicityRule() { |
| 2008 | return getFieldRelationInterpretationAccess().getRule(); | 3208 | return getBoundedMultiplicityAccess().getRule(); |
| 2009 | } | 3209 | } |
| 2010 | 3210 | ||
| 2011 | //GlobalRelationInterpretation: | 3211 | //ScopeDefinition: |
| 2012 | // containment?='containment'? 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? | 3212 | // ExactScopeDefinition | BoundedScopeDefinition | LowerBoundedScopeDefinition; |
| 2013 | // source=Symbol targetMultiplicity=MultiplicityDefinition? target=Symbol; | 3213 | public ScopeDefinitionElements getScopeDefinitionAccess() { |
| 2014 | public GlobalRelationInterpretationElements getGlobalRelationInterpretationAccess() { | 3214 | return pScopeDefinition; |
| 2015 | return pGlobalRelationInterpretation; | ||
| 2016 | } | 3215 | } |
| 2017 | 3216 | ||
| 2018 | public ParserRule getGlobalRelationInterpretationRule() { | 3217 | public ParserRule getScopeDefinitionRule() { |
| 2019 | return getGlobalRelationInterpretationAccess().getRule(); | 3218 | return getScopeDefinitionAccess().getRule(); |
| 2020 | } | 3219 | } |
| 2021 | 3220 | ||
| 2022 | //MultiplicityDefinition: | 3221 | //ExactScopeDefinition: |
| 2023 | // lower=INT '..' (upper=INT | unlimitedUpper?='*'); | 3222 | // "scope" type=[NamedElement|QualifiedName] "==" exactScope=INT; |
| 2024 | public MultiplicityDefinitionElements getMultiplicityDefinitionAccess() { | 3223 | public ExactScopeDefinitionElements getExactScopeDefinitionAccess() { |
| 2025 | return pMultiplicityDefinition; | 3224 | return pExactScopeDefinition; |
| 2026 | } | 3225 | } |
| 2027 | 3226 | ||
| 2028 | public ParserRule getMultiplicityDefinitionRule() { | 3227 | public ParserRule getExactScopeDefinitionRule() { |
| 2029 | return getMultiplicityDefinitionAccess().getRule(); | 3228 | return getExactScopeDefinitionAccess().getRule(); |
| 3229 | } | ||
| 3230 | |||
| 3231 | //BoundedScopeDefinition: | ||
| 3232 | // "scope" ((lowerBound=INT "<=")? type=[NamedElement|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" | ||
| 3233 | // type=[NamedElement|QualifiedName] (">=" lowerBound=INT)?); | ||
| 3234 | public BoundedScopeDefinitionElements getBoundedScopeDefinitionAccess() { | ||
| 3235 | return pBoundedScopeDefinition; | ||
| 3236 | } | ||
| 3237 | |||
| 3238 | public ParserRule getBoundedScopeDefinitionRule() { | ||
| 3239 | return getBoundedScopeDefinitionAccess().getRule(); | ||
| 3240 | } | ||
| 3241 | |||
| 3242 | //LowerBoundedScopeDefinition: | ||
| 3243 | // "scope" (lowerBound=INT "<=" type=[NamedElement|QualifiedName] | type=[NamedElement|QualifiedName] ">=" | ||
| 3244 | // lowerBound=INT); | ||
| 3245 | public LowerBoundedScopeDefinitionElements getLowerBoundedScopeDefinitionAccess() { | ||
| 3246 | return pLowerBoundedScopeDefinition; | ||
| 3247 | } | ||
| 3248 | |||
| 3249 | public ParserRule getLowerBoundedScopeDefinitionRule() { | ||
| 3250 | return getLowerBoundedScopeDefinitionAccess().getRule(); | ||
| 3251 | } | ||
| 3252 | |||
| 3253 | //enum ObjectiveKind: | ||
| 3254 | // MINIMIZE="minimize" | MAXIMIZE="maximize"; | ||
| 3255 | public ObjectiveKindElements getObjectiveKindAccess() { | ||
| 3256 | return eObjectiveKind; | ||
| 3257 | } | ||
| 3258 | |||
| 3259 | public EnumRule getObjectiveKindRule() { | ||
| 3260 | return getObjectiveKindAccess().getRule(); | ||
| 3261 | } | ||
| 3262 | |||
| 3263 | //ObjectiveDefinition: | ||
| 3264 | // kind=ObjectiveKind objective=Expression; | ||
| 3265 | public ObjectiveDefinitionElements getObjectiveDefinitionAccess() { | ||
| 3266 | return pObjectiveDefinition; | ||
| 3267 | } | ||
| 3268 | |||
| 3269 | public ParserRule getObjectiveDefinitionRule() { | ||
| 3270 | return getObjectiveDefinitionAccess().getRule(); | ||
| 3271 | } | ||
| 3272 | |||
| 3273 | //UpperMultiplicty ecore::EInt: | ||
| 3274 | // INT | "*"; | ||
| 3275 | public UpperMultiplictyElements getUpperMultiplictyAccess() { | ||
| 3276 | return pUpperMultiplicty; | ||
| 3277 | } | ||
| 3278 | |||
| 3279 | public ParserRule getUpperMultiplictyRule() { | ||
| 3280 | return getUpperMultiplictyAccess().getRule(); | ||
| 3281 | } | ||
| 3282 | |||
| 3283 | //Real ecore::EBigDecimal hidden(): | ||
| 3284 | // INT ("." INT)?; | ||
| 3285 | public RealElements getRealAccess() { | ||
| 3286 | return pReal; | ||
| 3287 | } | ||
| 3288 | |||
| 3289 | public ParserRule getRealRule() { | ||
| 3290 | return getRealAccess().getRule(); | ||
| 3291 | } | ||
| 3292 | |||
| 3293 | //QualifiedName hidden(): | ||
| 3294 | // ID ("." ID)* | QUOTED_ID; | ||
| 3295 | public QualifiedNameElements getQualifiedNameAccess() { | ||
| 3296 | return pQualifiedName; | ||
| 3297 | } | ||
| 3298 | |||
| 3299 | public ParserRule getQualifiedNameRule() { | ||
| 3300 | return getQualifiedNameAccess().getRule(); | ||
| 3301 | } | ||
| 3302 | |||
| 3303 | //@Override | ||
| 3304 | //terminal STRING: | ||
| 3305 | // '"' ('\\' . | !('\\' | '"'))* '"'; | ||
| 3306 | public TerminalRule getSTRINGRule() { | ||
| 3307 | return tSTRING; | ||
| 3308 | } | ||
| 3309 | |||
| 3310 | //terminal QUOTED_ID: | ||
| 3311 | // '\'' ('\\' . | !('\\' | '\''))* '\''; | ||
| 3312 | public TerminalRule getQUOTED_IDRule() { | ||
| 3313 | return tQUOTED_ID; | ||
| 3314 | } | ||
| 3315 | |||
| 3316 | //@Override | ||
| 3317 | //terminal SL_COMMENT: | ||
| 3318 | // ('%' | '//') !('\n' | '\r')* ('\r'? '\n')?; | ||
| 3319 | public TerminalRule getSL_COMMENTRule() { | ||
| 3320 | return tSL_COMMENT; | ||
| 3321 | } | ||
| 3322 | |||
| 3323 | //terminal TRANSITIVE_CLOSURE: | ||
| 3324 | // "synthetic:TRANSITIVE_CLOSURE"; | ||
| 3325 | public TerminalRule getTRANSITIVE_CLOSURERule() { | ||
| 3326 | return tTRANSITIVE_CLOSURE; | ||
| 3327 | } | ||
| 3328 | |||
| 3329 | //terminal REFLEXIVE_TRANSITIVE_CLOSURE: | ||
| 3330 | // "synthetic:REFLEXIVE_TRANSITIVE_CLOSURE"; | ||
| 3331 | public TerminalRule getREFLEXIVE_TRANSITIVE_CLOSURERule() { | ||
| 3332 | return tREFLEXIVE_TRANSITIVE_CLOSURE; | ||
| 3333 | } | ||
| 3334 | |||
| 3335 | //terminal FULL_STOP: | ||
| 3336 | // "synthetic:FULL_STOP"; | ||
| 3337 | public TerminalRule getFULL_STOPRule() { | ||
| 3338 | return tFULL_STOP; | ||
| 3339 | } | ||
| 3340 | |||
| 3341 | //NamedElement: | ||
| 3342 | // name=QualifiedName; | ||
| 3343 | public NamedElementElements getNamedElementAccess() { | ||
| 3344 | return pNamedElement; | ||
| 3345 | } | ||
| 3346 | |||
| 3347 | public ParserRule getNamedElementRule() { | ||
| 3348 | return getNamedElementAccess().getRule(); | ||
| 2030 | } | 3349 | } |
| 2031 | 3350 | ||
| 2032 | //terminal ID: | 3351 | //terminal ID: |
| @@ -2047,12 +3366,6 @@ public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | |||
| 2047 | return gaTerminals.getML_COMMENTRule(); | 3366 | return gaTerminals.getML_COMMENTRule(); |
| 2048 | } | 3367 | } |
| 2049 | 3368 | ||
| 2050 | //terminal SL_COMMENT: | ||
| 2051 | // '//' !('\n' | '\r')* ('\r'? '\n')?; | ||
| 2052 | public TerminalRule getSL_COMMENTRule() { | ||
| 2053 | return gaTerminals.getSL_COMMENTRule(); | ||
| 2054 | } | ||
| 2055 | |||
| 2056 | //terminal WS: | 3369 | //terminal WS: |
| 2057 | // ' ' | '\t' | '\r' | '\n'+; | 3370 | // ' ' | '\t' | '\r' | '\n'+; |
| 2058 | public TerminalRule getWSRule() { | 3371 | public TerminalRule getWSRule() { |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Aggregation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Aggregation.java new file mode 100644 index 00000000..8641f197 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Aggregation.java | |||
| @@ -0,0 +1,96 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Aggregation</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getOp <em>Op</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getBody <em>Body</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getCondition <em>Condition</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAggregation() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface Aggregation extends Expression | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Op</b></em>' attribute. | ||
| 29 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.AggregationOp}. | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @return the value of the '<em>Op</em>' attribute. | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOp | ||
| 34 | * @see #setOp(AggregationOp) | ||
| 35 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAggregation_Op() | ||
| 36 | * @model | ||
| 37 | * @generated | ||
| 38 | */ | ||
| 39 | AggregationOp getOp(); | ||
| 40 | |||
| 41 | /** | ||
| 42 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getOp <em>Op</em>}' attribute. | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @param value the new value of the '<em>Op</em>' attribute. | ||
| 46 | * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOp | ||
| 47 | * @see #getOp() | ||
| 48 | * @generated | ||
| 49 | */ | ||
| 50 | void setOp(AggregationOp value); | ||
| 51 | |||
| 52 | /** | ||
| 53 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 54 | * <!-- begin-user-doc --> | ||
| 55 | * <!-- end-user-doc --> | ||
| 56 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 57 | * @see #setBody(Expression) | ||
| 58 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAggregation_Body() | ||
| 59 | * @model containment="true" | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | Expression getBody(); | ||
| 63 | |||
| 64 | /** | ||
| 65 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getBody <em>Body</em>}' containment reference. | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 69 | * @see #getBody() | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | void setBody(Expression value); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Returns the value of the '<em><b>Condition</b></em>' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Condition</em>' containment reference. | ||
| 79 | * @see #setCondition(Expression) | ||
| 80 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAggregation_Condition() | ||
| 81 | * @model containment="true" | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | Expression getCondition(); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getCondition <em>Condition</em>}' containment reference. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param value the new value of the '<em>Condition</em>' containment reference. | ||
| 91 | * @see #getCondition() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setCondition(Expression value); | ||
| 95 | |||
| 96 | } // Aggregation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AggregationOp.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AggregationOp.java new file mode 100644 index 00000000..1a0664ed --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AggregationOp.java | |||
| @@ -0,0 +1,317 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Aggregation Op</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAggregationOp() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum AggregationOp implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>ONLY</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #ONLY_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | ONLY(0, "ONLY", "only"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>SUM</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #SUM_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | SUM(1, "SUM", "sum"), | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>PROD</b></em>' literal object. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #PROD_VALUE | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | PROD(2, "PROD", "prod"), | ||
| 52 | |||
| 53 | /** | ||
| 54 | * The '<em><b>AVG</b></em>' literal object. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @see #AVG_VALUE | ||
| 58 | * @generated | ||
| 59 | * @ordered | ||
| 60 | */ | ||
| 61 | AVG(3, "AVG", "avg"), | ||
| 62 | |||
| 63 | /** | ||
| 64 | * The '<em><b>MIN</b></em>' literal object. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @see #MIN_VALUE | ||
| 68 | * @generated | ||
| 69 | * @ordered | ||
| 70 | */ | ||
| 71 | MIN(4, "MIN", "min"), | ||
| 72 | |||
| 73 | /** | ||
| 74 | * The '<em><b>MAX</b></em>' literal object. | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @see #MAX_VALUE | ||
| 78 | * @generated | ||
| 79 | * @ordered | ||
| 80 | */ | ||
| 81 | MAX(5, "MAX", "max"); | ||
| 82 | |||
| 83 | /** | ||
| 84 | * The '<em><b>ONLY</b></em>' literal value. | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @see #ONLY | ||
| 88 | * @model literal="only" | ||
| 89 | * @generated | ||
| 90 | * @ordered | ||
| 91 | */ | ||
| 92 | public static final int ONLY_VALUE = 0; | ||
| 93 | |||
| 94 | /** | ||
| 95 | * The '<em><b>SUM</b></em>' literal value. | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @see #SUM | ||
| 99 | * @model literal="sum" | ||
| 100 | * @generated | ||
| 101 | * @ordered | ||
| 102 | */ | ||
| 103 | public static final int SUM_VALUE = 1; | ||
| 104 | |||
| 105 | /** | ||
| 106 | * The '<em><b>PROD</b></em>' literal value. | ||
| 107 | * <!-- begin-user-doc --> | ||
| 108 | * <!-- end-user-doc --> | ||
| 109 | * @see #PROD | ||
| 110 | * @model literal="prod" | ||
| 111 | * @generated | ||
| 112 | * @ordered | ||
| 113 | */ | ||
| 114 | public static final int PROD_VALUE = 2; | ||
| 115 | |||
| 116 | /** | ||
| 117 | * The '<em><b>AVG</b></em>' literal value. | ||
| 118 | * <!-- begin-user-doc --> | ||
| 119 | * <!-- end-user-doc --> | ||
| 120 | * @see #AVG | ||
| 121 | * @model literal="avg" | ||
| 122 | * @generated | ||
| 123 | * @ordered | ||
| 124 | */ | ||
| 125 | public static final int AVG_VALUE = 3; | ||
| 126 | |||
| 127 | /** | ||
| 128 | * The '<em><b>MIN</b></em>' literal value. | ||
| 129 | * <!-- begin-user-doc --> | ||
| 130 | * <!-- end-user-doc --> | ||
| 131 | * @see #MIN | ||
| 132 | * @model literal="min" | ||
| 133 | * @generated | ||
| 134 | * @ordered | ||
| 135 | */ | ||
| 136 | public static final int MIN_VALUE = 4; | ||
| 137 | |||
| 138 | /** | ||
| 139 | * The '<em><b>MAX</b></em>' literal value. | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @see #MAX | ||
| 143 | * @model literal="max" | ||
| 144 | * @generated | ||
| 145 | * @ordered | ||
| 146 | */ | ||
| 147 | public static final int MAX_VALUE = 5; | ||
| 148 | |||
| 149 | /** | ||
| 150 | * An array of all the '<em><b>Aggregation Op</b></em>' enumerators. | ||
| 151 | * <!-- begin-user-doc --> | ||
| 152 | * <!-- end-user-doc --> | ||
| 153 | * @generated | ||
| 154 | */ | ||
| 155 | private static final AggregationOp[] VALUES_ARRAY = | ||
| 156 | new AggregationOp[] | ||
| 157 | { | ||
| 158 | ONLY, | ||
| 159 | SUM, | ||
| 160 | PROD, | ||
| 161 | AVG, | ||
| 162 | MIN, | ||
| 163 | MAX, | ||
| 164 | }; | ||
| 165 | |||
| 166 | /** | ||
| 167 | * A public read-only list of all the '<em><b>Aggregation Op</b></em>' enumerators. | ||
| 168 | * <!-- begin-user-doc --> | ||
| 169 | * <!-- end-user-doc --> | ||
| 170 | * @generated | ||
| 171 | */ | ||
| 172 | public static final List<AggregationOp> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 173 | |||
| 174 | /** | ||
| 175 | * Returns the '<em><b>Aggregation Op</b></em>' literal with the specified literal value. | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @param literal the literal. | ||
| 179 | * @return the matching enumerator or <code>null</code>. | ||
| 180 | * @generated | ||
| 181 | */ | ||
| 182 | public static AggregationOp get(String literal) | ||
| 183 | { | ||
| 184 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 185 | { | ||
| 186 | AggregationOp result = VALUES_ARRAY[i]; | ||
| 187 | if (result.toString().equals(literal)) | ||
| 188 | { | ||
| 189 | return result; | ||
| 190 | } | ||
| 191 | } | ||
| 192 | return null; | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * Returns the '<em><b>Aggregation Op</b></em>' literal with the specified name. | ||
| 197 | * <!-- begin-user-doc --> | ||
| 198 | * <!-- end-user-doc --> | ||
| 199 | * @param name the name. | ||
| 200 | * @return the matching enumerator or <code>null</code>. | ||
| 201 | * @generated | ||
| 202 | */ | ||
| 203 | public static AggregationOp getByName(String name) | ||
| 204 | { | ||
| 205 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 206 | { | ||
| 207 | AggregationOp result = VALUES_ARRAY[i]; | ||
| 208 | if (result.getName().equals(name)) | ||
| 209 | { | ||
| 210 | return result; | ||
| 211 | } | ||
| 212 | } | ||
| 213 | return null; | ||
| 214 | } | ||
| 215 | |||
| 216 | /** | ||
| 217 | * Returns the '<em><b>Aggregation Op</b></em>' literal with the specified integer value. | ||
| 218 | * <!-- begin-user-doc --> | ||
| 219 | * <!-- end-user-doc --> | ||
| 220 | * @param value the integer value. | ||
| 221 | * @return the matching enumerator or <code>null</code>. | ||
| 222 | * @generated | ||
| 223 | */ | ||
| 224 | public static AggregationOp get(int value) | ||
| 225 | { | ||
| 226 | switch (value) | ||
| 227 | { | ||
| 228 | case ONLY_VALUE: return ONLY; | ||
| 229 | case SUM_VALUE: return SUM; | ||
| 230 | case PROD_VALUE: return PROD; | ||
| 231 | case AVG_VALUE: return AVG; | ||
| 232 | case MIN_VALUE: return MIN; | ||
| 233 | case MAX_VALUE: return MAX; | ||
| 234 | } | ||
| 235 | return null; | ||
| 236 | } | ||
| 237 | |||
| 238 | /** | ||
| 239 | * <!-- begin-user-doc --> | ||
| 240 | * <!-- end-user-doc --> | ||
| 241 | * @generated | ||
| 242 | */ | ||
| 243 | private final int value; | ||
| 244 | |||
| 245 | /** | ||
| 246 | * <!-- begin-user-doc --> | ||
| 247 | * <!-- end-user-doc --> | ||
| 248 | * @generated | ||
| 249 | */ | ||
| 250 | private final String name; | ||
| 251 | |||
| 252 | /** | ||
| 253 | * <!-- begin-user-doc --> | ||
| 254 | * <!-- end-user-doc --> | ||
| 255 | * @generated | ||
| 256 | */ | ||
| 257 | private final String literal; | ||
| 258 | |||
| 259 | /** | ||
| 260 | * Only this class can construct instances. | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | private AggregationOp(int value, String name, String literal) | ||
| 266 | { | ||
| 267 | this.value = value; | ||
| 268 | this.name = name; | ||
| 269 | this.literal = literal; | ||
| 270 | } | ||
| 271 | |||
| 272 | /** | ||
| 273 | * <!-- begin-user-doc --> | ||
| 274 | * <!-- end-user-doc --> | ||
| 275 | * @generated | ||
| 276 | */ | ||
| 277 | @Override | ||
| 278 | public int getValue() | ||
| 279 | { | ||
| 280 | return value; | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public String getName() | ||
| 290 | { | ||
| 291 | return name; | ||
| 292 | } | ||
| 293 | |||
| 294 | /** | ||
| 295 | * <!-- begin-user-doc --> | ||
| 296 | * <!-- end-user-doc --> | ||
| 297 | * @generated | ||
| 298 | */ | ||
| 299 | @Override | ||
| 300 | public String getLiteral() | ||
| 301 | { | ||
| 302 | return literal; | ||
| 303 | } | ||
| 304 | |||
| 305 | /** | ||
| 306 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public String toString() | ||
| 313 | { | ||
| 314 | return literal; | ||
| 315 | } | ||
| 316 | |||
| 317 | } //AggregationOp | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java deleted file mode 100644 index 17cb45fb..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>All Instances</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface AllInstances extends ComplexObject | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 30 | * @see #setSymbol(Symbol) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances_Symbol() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | Symbol getSymbol(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 42 | * @see #getSymbol() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setSymbol(Symbol value); | ||
| 46 | |||
| 47 | } // AllInstances | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java deleted file mode 100644 index fbb18046..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>All Objects</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllObjects() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface AllObjects extends ComplexObject | ||
| 18 | { | ||
| 19 | } // AllObjects | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Argument.java index ba30c6ad..73c79940 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Argument.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -7,14 +7,14 @@ import org.eclipse.emf.ecore.EObject; | |||
| 7 | 7 | ||
| 8 | /** | 8 | /** |
| 9 | * <!-- begin-user-doc --> | 9 | * <!-- begin-user-doc --> |
| 10 | * A representation of the model object '<em><b>Polarity</b></em>'. | 10 | * A representation of the model object '<em><b>Argument</b></em>'. |
| 11 | * <!-- end-user-doc --> | 11 | * <!-- end-user-doc --> |
| 12 | * | 12 | * |
| 13 | * | 13 | * |
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPolarity() | 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getArgument() |
| 15 | * @model | 15 | * @model |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public interface Polarity extends EObject | 18 | public interface Argument extends EObject |
| 19 | { | 19 | { |
| 20 | } // Polarity | 20 | } // Argument |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ArgumentList.java index 62be12a1..4a932fea 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ArgumentList.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -9,32 +9,32 @@ import org.eclipse.emf.ecore.EObject; | |||
| 9 | 9 | ||
| 10 | /** | 10 | /** |
| 11 | * <!-- begin-user-doc --> | 11 | * <!-- begin-user-doc --> |
| 12 | * A representation of the model object '<em><b>Pattern Body</b></em>'. | 12 | * A representation of the model object '<em><b>Argument List</b></em>'. |
| 13 | * <!-- end-user-doc --> | 13 | * <!-- end-user-doc --> |
| 14 | * | 14 | * |
| 15 | * <p> | 15 | * <p> |
| 16 | * The following features are supported: | 16 | * The following features are supported: |
| 17 | * </p> | 17 | * </p> |
| 18 | * <ul> | 18 | * <ul> |
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints <em>Constraints</em>}</li> | 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ArgumentList#getArguments <em>Arguments</em>}</li> |
| 20 | * </ul> | 20 | * </ul> |
| 21 | * | 21 | * |
| 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody() | 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getArgumentList() |
| 23 | * @model | 23 | * @model |
| 24 | * @generated | 24 | * @generated |
| 25 | */ | 25 | */ |
| 26 | public interface PatternBody extends EObject | 26 | public interface ArgumentList extends EObject |
| 27 | { | 27 | { |
| 28 | /** | 28 | /** |
| 29 | * Returns the value of the '<em><b>Constraints</b></em>' containment reference list. | 29 | * Returns the value of the '<em><b>Arguments</b></em>' containment reference list. |
| 30 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint}. | 30 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Argument}. |
| 31 | * <!-- begin-user-doc --> | 31 | * <!-- begin-user-doc --> |
| 32 | * <!-- end-user-doc --> | 32 | * <!-- end-user-doc --> |
| 33 | * @return the value of the '<em>Constraints</em>' containment reference list. | 33 | * @return the value of the '<em>Arguments</em>' containment reference list. |
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody_Constraints() | 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getArgumentList_Arguments() |
| 35 | * @model containment="true" | 35 | * @model containment="true" |
| 36 | * @generated | 36 | * @generated |
| 37 | */ | 37 | */ |
| 38 | EList<Constraint> getConstraints(); | 38 | EList<Argument> getArguments(); |
| 39 | 39 | ||
| 40 | } // PatternBody | 40 | } // ArgumentList |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Assertion.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Assertion.java new file mode 100644 index 00000000..b67d81ca --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Assertion.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Assertion</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getBody <em>Body</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getRange <em>Range</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAssertion() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Assertion extends Statement | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 31 | * @see #setBody(Expression) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAssertion_Body() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | Expression getBody(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getBody <em>Body</em>}' containment reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 43 | * @see #getBody() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setBody(Expression value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Range</b></em>' containment reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Range</em>' containment reference. | ||
| 53 | * @see #setRange(Expression) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAssertion_Range() | ||
| 55 | * @model containment="true" | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | Expression getRange(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getRange <em>Range</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Range</em>' containment reference. | ||
| 65 | * @see #getRange() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setRange(Expression value); | ||
| 69 | |||
| 70 | } // Assertion | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java deleted file mode 100644 index b4226d4a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java +++ /dev/null | |||
| @@ -1,84 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Basic Interpretation</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects <em>Objects</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}</li> | ||
| 20 | * </ul> | ||
| 21 | * | ||
| 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation() | ||
| 23 | * @model | ||
| 24 | * @generated | ||
| 25 | */ | ||
| 26 | public interface BasicInterpretation extends Interpretation | ||
| 27 | { | ||
| 28 | /** | ||
| 29 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 33 | * @see #setSymbol(Symbol) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Symbol() | ||
| 35 | * @model containment="true" | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | Symbol getSymbol(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}' containment reference. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 45 | * @see #getSymbol() | ||
| 46 | * @generated | ||
| 47 | */ | ||
| 48 | void setSymbol(Symbol value); | ||
| 49 | |||
| 50 | /** | ||
| 51 | * Returns the value of the '<em><b>Objects</b></em>' containment reference list. | ||
| 52 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject}. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Objects</em>' containment reference list. | ||
| 56 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Objects() | ||
| 57 | * @model containment="true" | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | EList<ComplexObject> getObjects(); | ||
| 61 | |||
| 62 | /** | ||
| 63 | * Returns the value of the '<em><b>Value</b></em>' containment reference. | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @return the value of the '<em>Value</em>' containment reference. | ||
| 67 | * @see #setValue(TruthValue) | ||
| 68 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Value() | ||
| 69 | * @model containment="true" | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | TruthValue getValue(); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @param value the new value of the '<em>Value</em>' containment reference. | ||
| 79 | * @see #getValue() | ||
| 80 | * @generated | ||
| 81 | */ | ||
| 82 | void setValue(TruthValue value); | ||
| 83 | |||
| 84 | } // BasicInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryExpression.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryExpression.java new file mode 100644 index 00000000..8a81e68b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryExpression.java | |||
| @@ -0,0 +1,96 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Binary Expression</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getLeft <em>Left</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getOp <em>Op</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getRight <em>Right</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBinaryExpression() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface BinaryExpression extends Expression | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Left</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Left</em>' containment reference. | ||
| 32 | * @see #setLeft(Expression) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBinaryExpression_Left() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | Expression getLeft(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getLeft <em>Left</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Left</em>' containment reference. | ||
| 44 | * @see #getLeft() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setLeft(Expression value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Op</b></em>' attribute. | ||
| 51 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator}. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Op</em>' attribute. | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 56 | * @see #setOp(BinaryOperator) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBinaryExpression_Op() | ||
| 58 | * @model | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | BinaryOperator getOp(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getOp <em>Op</em>}' attribute. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Op</em>' attribute. | ||
| 68 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 69 | * @see #getOp() | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | void setOp(BinaryOperator value); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Returns the value of the '<em><b>Right</b></em>' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Right</em>' containment reference. | ||
| 79 | * @see #setRight(Expression) | ||
| 80 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBinaryExpression_Right() | ||
| 81 | * @model containment="true" | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | Expression getRight(); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getRight <em>Right</em>}' containment reference. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param value the new value of the '<em>Right</em>' containment reference. | ||
| 91 | * @see #getRight() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setRight(Expression value); | ||
| 95 | |||
| 96 | } // BinaryExpression | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryOperator.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryOperator.java new file mode 100644 index 00000000..9e8e073a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BinaryOperator.java | |||
| @@ -0,0 +1,455 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Binary Operator</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBinaryOperator() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum BinaryOperator implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>EQ</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #EQ_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | EQ(0, "EQ", "EQ"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>NOT EQ</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #NOT_EQ_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | NOT_EQ(1, "NOT_EQ", "NOT_EQ"), | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>LESS</b></em>' literal object. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #LESS_VALUE | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | LESS(2, "LESS", "LESS"), | ||
| 52 | |||
| 53 | /** | ||
| 54 | * The '<em><b>LESS EQ</b></em>' literal object. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @see #LESS_EQ_VALUE | ||
| 58 | * @generated | ||
| 59 | * @ordered | ||
| 60 | */ | ||
| 61 | LESS_EQ(3, "LESS_EQ", "LESS_EQ"), | ||
| 62 | |||
| 63 | /** | ||
| 64 | * The '<em><b>GREATER</b></em>' literal object. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @see #GREATER_VALUE | ||
| 68 | * @generated | ||
| 69 | * @ordered | ||
| 70 | */ | ||
| 71 | GREATER(4, "GREATER", "GREATER"), | ||
| 72 | |||
| 73 | /** | ||
| 74 | * The '<em><b>GREATER EQ</b></em>' literal object. | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @see #GREATER_EQ_VALUE | ||
| 78 | * @generated | ||
| 79 | * @ordered | ||
| 80 | */ | ||
| 81 | GREATER_EQ(5, "GREATER_EQ", "GREATER_EQ"), | ||
| 82 | |||
| 83 | /** | ||
| 84 | * The '<em><b>IN</b></em>' literal object. | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @see #IN_VALUE | ||
| 88 | * @generated | ||
| 89 | * @ordered | ||
| 90 | */ | ||
| 91 | IN(6, "IN", "IN"), | ||
| 92 | |||
| 93 | /** | ||
| 94 | * The '<em><b>ADD</b></em>' literal object. | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @see #ADD_VALUE | ||
| 98 | * @generated | ||
| 99 | * @ordered | ||
| 100 | */ | ||
| 101 | ADD(7, "ADD", "ADD"), | ||
| 102 | |||
| 103 | /** | ||
| 104 | * The '<em><b>SUB</b></em>' literal object. | ||
| 105 | * <!-- begin-user-doc --> | ||
| 106 | * <!-- end-user-doc --> | ||
| 107 | * @see #SUB_VALUE | ||
| 108 | * @generated | ||
| 109 | * @ordered | ||
| 110 | */ | ||
| 111 | SUB(8, "SUB", "SUB"), | ||
| 112 | |||
| 113 | /** | ||
| 114 | * The '<em><b>MUL</b></em>' literal object. | ||
| 115 | * <!-- begin-user-doc --> | ||
| 116 | * <!-- end-user-doc --> | ||
| 117 | * @see #MUL_VALUE | ||
| 118 | * @generated | ||
| 119 | * @ordered | ||
| 120 | */ | ||
| 121 | MUL(9, "MUL", "MUL"), | ||
| 122 | |||
| 123 | /** | ||
| 124 | * The '<em><b>DIV</b></em>' literal object. | ||
| 125 | * <!-- begin-user-doc --> | ||
| 126 | * <!-- end-user-doc --> | ||
| 127 | * @see #DIV_VALUE | ||
| 128 | * @generated | ||
| 129 | * @ordered | ||
| 130 | */ | ||
| 131 | DIV(10, "DIV", "DIV"), | ||
| 132 | |||
| 133 | /** | ||
| 134 | * The '<em><b>POW</b></em>' literal object. | ||
| 135 | * <!-- begin-user-doc --> | ||
| 136 | * <!-- end-user-doc --> | ||
| 137 | * @see #POW_VALUE | ||
| 138 | * @generated | ||
| 139 | * @ordered | ||
| 140 | */ | ||
| 141 | POW(11, "POW", "POW"); | ||
| 142 | |||
| 143 | /** | ||
| 144 | * The '<em><b>EQ</b></em>' literal value. | ||
| 145 | * <!-- begin-user-doc --> | ||
| 146 | * <!-- end-user-doc --> | ||
| 147 | * @see #EQ | ||
| 148 | * @model | ||
| 149 | * @generated | ||
| 150 | * @ordered | ||
| 151 | */ | ||
| 152 | public static final int EQ_VALUE = 0; | ||
| 153 | |||
| 154 | /** | ||
| 155 | * The '<em><b>NOT EQ</b></em>' literal value. | ||
| 156 | * <!-- begin-user-doc --> | ||
| 157 | * <!-- end-user-doc --> | ||
| 158 | * @see #NOT_EQ | ||
| 159 | * @model | ||
| 160 | * @generated | ||
| 161 | * @ordered | ||
| 162 | */ | ||
| 163 | public static final int NOT_EQ_VALUE = 1; | ||
| 164 | |||
| 165 | /** | ||
| 166 | * The '<em><b>LESS</b></em>' literal value. | ||
| 167 | * <!-- begin-user-doc --> | ||
| 168 | * <!-- end-user-doc --> | ||
| 169 | * @see #LESS | ||
| 170 | * @model | ||
| 171 | * @generated | ||
| 172 | * @ordered | ||
| 173 | */ | ||
| 174 | public static final int LESS_VALUE = 2; | ||
| 175 | |||
| 176 | /** | ||
| 177 | * The '<em><b>LESS EQ</b></em>' literal value. | ||
| 178 | * <!-- begin-user-doc --> | ||
| 179 | * <!-- end-user-doc --> | ||
| 180 | * @see #LESS_EQ | ||
| 181 | * @model | ||
| 182 | * @generated | ||
| 183 | * @ordered | ||
| 184 | */ | ||
| 185 | public static final int LESS_EQ_VALUE = 3; | ||
| 186 | |||
| 187 | /** | ||
| 188 | * The '<em><b>GREATER</b></em>' literal value. | ||
| 189 | * <!-- begin-user-doc --> | ||
| 190 | * <!-- end-user-doc --> | ||
| 191 | * @see #GREATER | ||
| 192 | * @model | ||
| 193 | * @generated | ||
| 194 | * @ordered | ||
| 195 | */ | ||
| 196 | public static final int GREATER_VALUE = 4; | ||
| 197 | |||
| 198 | /** | ||
| 199 | * The '<em><b>GREATER EQ</b></em>' literal value. | ||
| 200 | * <!-- begin-user-doc --> | ||
| 201 | * <!-- end-user-doc --> | ||
| 202 | * @see #GREATER_EQ | ||
| 203 | * @model | ||
| 204 | * @generated | ||
| 205 | * @ordered | ||
| 206 | */ | ||
| 207 | public static final int GREATER_EQ_VALUE = 5; | ||
| 208 | |||
| 209 | /** | ||
| 210 | * The '<em><b>IN</b></em>' literal value. | ||
| 211 | * <!-- begin-user-doc --> | ||
| 212 | * <!-- end-user-doc --> | ||
| 213 | * @see #IN | ||
| 214 | * @model | ||
| 215 | * @generated | ||
| 216 | * @ordered | ||
| 217 | */ | ||
| 218 | public static final int IN_VALUE = 6; | ||
| 219 | |||
| 220 | /** | ||
| 221 | * The '<em><b>ADD</b></em>' literal value. | ||
| 222 | * <!-- begin-user-doc --> | ||
| 223 | * <!-- end-user-doc --> | ||
| 224 | * @see #ADD | ||
| 225 | * @model | ||
| 226 | * @generated | ||
| 227 | * @ordered | ||
| 228 | */ | ||
| 229 | public static final int ADD_VALUE = 7; | ||
| 230 | |||
| 231 | /** | ||
| 232 | * The '<em><b>SUB</b></em>' literal value. | ||
| 233 | * <!-- begin-user-doc --> | ||
| 234 | * <!-- end-user-doc --> | ||
| 235 | * @see #SUB | ||
| 236 | * @model | ||
| 237 | * @generated | ||
| 238 | * @ordered | ||
| 239 | */ | ||
| 240 | public static final int SUB_VALUE = 8; | ||
| 241 | |||
| 242 | /** | ||
| 243 | * The '<em><b>MUL</b></em>' literal value. | ||
| 244 | * <!-- begin-user-doc --> | ||
| 245 | * <!-- end-user-doc --> | ||
| 246 | * @see #MUL | ||
| 247 | * @model | ||
| 248 | * @generated | ||
| 249 | * @ordered | ||
| 250 | */ | ||
| 251 | public static final int MUL_VALUE = 9; | ||
| 252 | |||
| 253 | /** | ||
| 254 | * The '<em><b>DIV</b></em>' literal value. | ||
| 255 | * <!-- begin-user-doc --> | ||
| 256 | * <!-- end-user-doc --> | ||
| 257 | * @see #DIV | ||
| 258 | * @model | ||
| 259 | * @generated | ||
| 260 | * @ordered | ||
| 261 | */ | ||
| 262 | public static final int DIV_VALUE = 10; | ||
| 263 | |||
| 264 | /** | ||
| 265 | * The '<em><b>POW</b></em>' literal value. | ||
| 266 | * <!-- begin-user-doc --> | ||
| 267 | * <!-- end-user-doc --> | ||
| 268 | * @see #POW | ||
| 269 | * @model | ||
| 270 | * @generated | ||
| 271 | * @ordered | ||
| 272 | */ | ||
| 273 | public static final int POW_VALUE = 11; | ||
| 274 | |||
| 275 | /** | ||
| 276 | * An array of all the '<em><b>Binary Operator</b></em>' enumerators. | ||
| 277 | * <!-- begin-user-doc --> | ||
| 278 | * <!-- end-user-doc --> | ||
| 279 | * @generated | ||
| 280 | */ | ||
| 281 | private static final BinaryOperator[] VALUES_ARRAY = | ||
| 282 | new BinaryOperator[] | ||
| 283 | { | ||
| 284 | EQ, | ||
| 285 | NOT_EQ, | ||
| 286 | LESS, | ||
| 287 | LESS_EQ, | ||
| 288 | GREATER, | ||
| 289 | GREATER_EQ, | ||
| 290 | IN, | ||
| 291 | ADD, | ||
| 292 | SUB, | ||
| 293 | MUL, | ||
| 294 | DIV, | ||
| 295 | POW, | ||
| 296 | }; | ||
| 297 | |||
| 298 | /** | ||
| 299 | * A public read-only list of all the '<em><b>Binary Operator</b></em>' enumerators. | ||
| 300 | * <!-- begin-user-doc --> | ||
| 301 | * <!-- end-user-doc --> | ||
| 302 | * @generated | ||
| 303 | */ | ||
| 304 | public static final List<BinaryOperator> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 305 | |||
| 306 | /** | ||
| 307 | * Returns the '<em><b>Binary Operator</b></em>' literal with the specified literal value. | ||
| 308 | * <!-- begin-user-doc --> | ||
| 309 | * <!-- end-user-doc --> | ||
| 310 | * @param literal the literal. | ||
| 311 | * @return the matching enumerator or <code>null</code>. | ||
| 312 | * @generated | ||
| 313 | */ | ||
| 314 | public static BinaryOperator get(String literal) | ||
| 315 | { | ||
| 316 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 317 | { | ||
| 318 | BinaryOperator result = VALUES_ARRAY[i]; | ||
| 319 | if (result.toString().equals(literal)) | ||
| 320 | { | ||
| 321 | return result; | ||
| 322 | } | ||
| 323 | } | ||
| 324 | return null; | ||
| 325 | } | ||
| 326 | |||
| 327 | /** | ||
| 328 | * Returns the '<em><b>Binary Operator</b></em>' literal with the specified name. | ||
| 329 | * <!-- begin-user-doc --> | ||
| 330 | * <!-- end-user-doc --> | ||
| 331 | * @param name the name. | ||
| 332 | * @return the matching enumerator or <code>null</code>. | ||
| 333 | * @generated | ||
| 334 | */ | ||
| 335 | public static BinaryOperator getByName(String name) | ||
| 336 | { | ||
| 337 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 338 | { | ||
| 339 | BinaryOperator result = VALUES_ARRAY[i]; | ||
| 340 | if (result.getName().equals(name)) | ||
| 341 | { | ||
| 342 | return result; | ||
| 343 | } | ||
| 344 | } | ||
| 345 | return null; | ||
| 346 | } | ||
| 347 | |||
| 348 | /** | ||
| 349 | * Returns the '<em><b>Binary Operator</b></em>' literal with the specified integer value. | ||
| 350 | * <!-- begin-user-doc --> | ||
| 351 | * <!-- end-user-doc --> | ||
| 352 | * @param value the integer value. | ||
| 353 | * @return the matching enumerator or <code>null</code>. | ||
| 354 | * @generated | ||
| 355 | */ | ||
| 356 | public static BinaryOperator get(int value) | ||
| 357 | { | ||
| 358 | switch (value) | ||
| 359 | { | ||
| 360 | case EQ_VALUE: return EQ; | ||
| 361 | case NOT_EQ_VALUE: return NOT_EQ; | ||
| 362 | case LESS_VALUE: return LESS; | ||
| 363 | case LESS_EQ_VALUE: return LESS_EQ; | ||
| 364 | case GREATER_VALUE: return GREATER; | ||
| 365 | case GREATER_EQ_VALUE: return GREATER_EQ; | ||
| 366 | case IN_VALUE: return IN; | ||
| 367 | case ADD_VALUE: return ADD; | ||
| 368 | case SUB_VALUE: return SUB; | ||
| 369 | case MUL_VALUE: return MUL; | ||
| 370 | case DIV_VALUE: return DIV; | ||
| 371 | case POW_VALUE: return POW; | ||
| 372 | } | ||
| 373 | return null; | ||
| 374 | } | ||
| 375 | |||
| 376 | /** | ||
| 377 | * <!-- begin-user-doc --> | ||
| 378 | * <!-- end-user-doc --> | ||
| 379 | * @generated | ||
| 380 | */ | ||
| 381 | private final int value; | ||
| 382 | |||
| 383 | /** | ||
| 384 | * <!-- begin-user-doc --> | ||
| 385 | * <!-- end-user-doc --> | ||
| 386 | * @generated | ||
| 387 | */ | ||
| 388 | private final String name; | ||
| 389 | |||
| 390 | /** | ||
| 391 | * <!-- begin-user-doc --> | ||
| 392 | * <!-- end-user-doc --> | ||
| 393 | * @generated | ||
| 394 | */ | ||
| 395 | private final String literal; | ||
| 396 | |||
| 397 | /** | ||
| 398 | * Only this class can construct instances. | ||
| 399 | * <!-- begin-user-doc --> | ||
| 400 | * <!-- end-user-doc --> | ||
| 401 | * @generated | ||
| 402 | */ | ||
| 403 | private BinaryOperator(int value, String name, String literal) | ||
| 404 | { | ||
| 405 | this.value = value; | ||
| 406 | this.name = name; | ||
| 407 | this.literal = literal; | ||
| 408 | } | ||
| 409 | |||
| 410 | /** | ||
| 411 | * <!-- begin-user-doc --> | ||
| 412 | * <!-- end-user-doc --> | ||
| 413 | * @generated | ||
| 414 | */ | ||
| 415 | @Override | ||
| 416 | public int getValue() | ||
| 417 | { | ||
| 418 | return value; | ||
| 419 | } | ||
| 420 | |||
| 421 | /** | ||
| 422 | * <!-- begin-user-doc --> | ||
| 423 | * <!-- end-user-doc --> | ||
| 424 | * @generated | ||
| 425 | */ | ||
| 426 | @Override | ||
| 427 | public String getName() | ||
| 428 | { | ||
| 429 | return name; | ||
| 430 | } | ||
| 431 | |||
| 432 | /** | ||
| 433 | * <!-- begin-user-doc --> | ||
| 434 | * <!-- end-user-doc --> | ||
| 435 | * @generated | ||
| 436 | */ | ||
| 437 | @Override | ||
| 438 | public String getLiteral() | ||
| 439 | { | ||
| 440 | return literal; | ||
| 441 | } | ||
| 442 | |||
| 443 | /** | ||
| 444 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 445 | * <!-- begin-user-doc --> | ||
| 446 | * <!-- end-user-doc --> | ||
| 447 | * @generated | ||
| 448 | */ | ||
| 449 | @Override | ||
| 450 | public String toString() | ||
| 451 | { | ||
| 452 | return literal; | ||
| 453 | } | ||
| 454 | |||
| 455 | } //BinaryOperator | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java deleted file mode 100644 index 678e8fee..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Boolean False</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanFalse() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface BooleanFalse extends BooleanValue | ||
| 18 | { | ||
| 19 | } // BooleanFalse | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java deleted file mode 100644 index c2c652ab..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Boolean Object</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface BooleanObject extends DataObject | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Value</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Value</em>' containment reference. | ||
| 30 | * @see #setValue(BooleanValue) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject_Value() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | BooleanValue getValue(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Value</em>' containment reference. | ||
| 42 | * @see #getValue() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setValue(BooleanValue value); | ||
| 46 | |||
| 47 | } // BooleanObject | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java deleted file mode 100644 index 4760c96c..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Boolean Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface BooleanSymbol extends DataSymbol | ||
| 18 | { | ||
| 19 | } // BooleanSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java deleted file mode 100644 index 7c72ec36..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Boolean True</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanTrue() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface BooleanTrue extends BooleanValue | ||
| 18 | { | ||
| 19 | } // BooleanTrue | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java deleted file mode 100644 index 8fe67a48..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Boolean Value</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * | ||
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanValue() | ||
| 15 | * @model | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public interface BooleanValue extends EObject | ||
| 19 | { | ||
| 20 | } // BooleanValue | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedMultiplicity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedMultiplicity.java new file mode 100644 index 00000000..8e81e1a2 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedMultiplicity.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Bounded Multiplicity</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getLowerBound <em>Lower Bound</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getUpperBound <em>Upper Bound</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedMultiplicity() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface BoundedMultiplicity extends Multiplicity | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Lower Bound</b></em>' attribute. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Lower Bound</em>' attribute. | ||
| 31 | * @see #setLowerBound(int) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedMultiplicity_LowerBound() | ||
| 33 | * @model | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | int getLowerBound(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getLowerBound <em>Lower Bound</em>}' attribute. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Lower Bound</em>' attribute. | ||
| 43 | * @see #getLowerBound() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setLowerBound(int value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Upper Bound</b></em>' attribute. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Upper Bound</em>' attribute. | ||
| 53 | * @see #setUpperBound(int) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedMultiplicity_UpperBound() | ||
| 55 | * @model | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | int getUpperBound(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getUpperBound <em>Upper Bound</em>}' attribute. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Upper Bound</em>' attribute. | ||
| 65 | * @see #getUpperBound() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setUpperBound(int value); | ||
| 69 | |||
| 70 | } // BoundedMultiplicity | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedScopeDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedScopeDefinition.java new file mode 100644 index 00000000..1e76e86a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BoundedScopeDefinition.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Bounded Scope Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getUpperBound <em>Upper Bound</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedScopeDefinition() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface BoundedScopeDefinition extends ScopeDefinition | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Lower Bound</b></em>' attribute. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Lower Bound</em>' attribute. | ||
| 31 | * @see #setLowerBound(int) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedScopeDefinition_LowerBound() | ||
| 33 | * @model | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | int getLowerBound(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}' attribute. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Lower Bound</em>' attribute. | ||
| 43 | * @see #getLowerBound() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setLowerBound(int value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Upper Bound</b></em>' attribute. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Upper Bound</em>' attribute. | ||
| 53 | * @see #setUpperBound(int) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBoundedScopeDefinition_UpperBound() | ||
| 55 | * @model | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | int getUpperBound(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getUpperBound <em>Upper Bound</em>}' attribute. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Upper Bound</em>' attribute. | ||
| 65 | * @see #getUpperBound() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setUpperBound(int value); | ||
| 69 | |||
| 70 | } // BoundedScopeDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java deleted file mode 100644 index 9a69fc8a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>CD Interpretation</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCDInterpretation() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface CDInterpretation extends Interpretation | ||
| 18 | { | ||
| 19 | } // CDInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Call.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Call.java new file mode 100644 index 00000000..70f7d15e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Call.java | |||
| @@ -0,0 +1,116 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Call</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getFunctor <em>Functor</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isTransitiveClosure <em>Transitive Closure</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isReflexiveTransitiveClosure <em>Reflexive Transitive Closure</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getArgumentList <em>Argument List</em>}</li> | ||
| 20 | * </ul> | ||
| 21 | * | ||
| 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCall() | ||
| 23 | * @model | ||
| 24 | * @generated | ||
| 25 | */ | ||
| 26 | public interface Call extends Expression | ||
| 27 | { | ||
| 28 | /** | ||
| 29 | * Returns the value of the '<em><b>Functor</b></em>' containment reference. | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @return the value of the '<em>Functor</em>' containment reference. | ||
| 33 | * @see #setFunctor(Reference) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCall_Functor() | ||
| 35 | * @model containment="true" | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | Reference getFunctor(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getFunctor <em>Functor</em>}' containment reference. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Functor</em>' containment reference. | ||
| 45 | * @see #getFunctor() | ||
| 46 | * @generated | ||
| 47 | */ | ||
| 48 | void setFunctor(Reference value); | ||
| 49 | |||
| 50 | /** | ||
| 51 | * Returns the value of the '<em><b>Transitive Closure</b></em>' attribute. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Transitive Closure</em>' attribute. | ||
| 55 | * @see #setTransitiveClosure(boolean) | ||
| 56 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCall_TransitiveClosure() | ||
| 57 | * @model | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | boolean isTransitiveClosure(); | ||
| 61 | |||
| 62 | /** | ||
| 63 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isTransitiveClosure <em>Transitive Closure</em>}' attribute. | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @param value the new value of the '<em>Transitive Closure</em>' attribute. | ||
| 67 | * @see #isTransitiveClosure() | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | void setTransitiveClosure(boolean value); | ||
| 71 | |||
| 72 | /** | ||
| 73 | * Returns the value of the '<em><b>Reflexive Transitive Closure</b></em>' attribute. | ||
| 74 | * <!-- begin-user-doc --> | ||
| 75 | * <!-- end-user-doc --> | ||
| 76 | * @return the value of the '<em>Reflexive Transitive Closure</em>' attribute. | ||
| 77 | * @see #setReflexiveTransitiveClosure(boolean) | ||
| 78 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCall_ReflexiveTransitiveClosure() | ||
| 79 | * @model | ||
| 80 | * @generated | ||
| 81 | */ | ||
| 82 | boolean isReflexiveTransitiveClosure(); | ||
| 83 | |||
| 84 | /** | ||
| 85 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isReflexiveTransitiveClosure <em>Reflexive Transitive Closure</em>}' attribute. | ||
| 86 | * <!-- begin-user-doc --> | ||
| 87 | * <!-- end-user-doc --> | ||
| 88 | * @param value the new value of the '<em>Reflexive Transitive Closure</em>' attribute. | ||
| 89 | * @see #isReflexiveTransitiveClosure() | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | void setReflexiveTransitiveClosure(boolean value); | ||
| 93 | |||
| 94 | /** | ||
| 95 | * Returns the value of the '<em><b>Argument List</b></em>' containment reference. | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @return the value of the '<em>Argument List</em>' containment reference. | ||
| 99 | * @see #setArgumentList(ArgumentList) | ||
| 100 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCall_ArgumentList() | ||
| 101 | * @model containment="true" | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | ArgumentList getArgumentList(); | ||
| 105 | |||
| 106 | /** | ||
| 107 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getArgumentList <em>Argument List</em>}' containment reference. | ||
| 108 | * <!-- begin-user-doc --> | ||
| 109 | * <!-- end-user-doc --> | ||
| 110 | * @param value the new value of the '<em>Argument List</em>' containment reference. | ||
| 111 | * @see #getArgumentList() | ||
| 112 | * @generated | ||
| 113 | */ | ||
| 114 | void setArgumentList(ArgumentList value); | ||
| 115 | |||
| 116 | } // Call | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Case.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Case.java new file mode 100644 index 00000000..970d1de2 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Case.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Case</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getCondition <em>Condition</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getBody <em>Body</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCase() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Case extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Condition</b></em>' containment reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Condition</em>' containment reference. | ||
| 31 | * @see #setCondition(Expression) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCase_Condition() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | Expression getCondition(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getCondition <em>Condition</em>}' containment reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Condition</em>' containment reference. | ||
| 43 | * @see #getCondition() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setCondition(Expression value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 53 | * @see #setBody(Expression) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCase_Body() | ||
| 55 | * @model containment="true" | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | Expression getBody(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getBody <em>Body</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 65 | * @see #getBody() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setBody(Expression value); | ||
| 69 | |||
| 70 | } // Case | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassDefinition.java index 777e0c50..9db15bfe 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassDefinition.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -7,24 +7,24 @@ import org.eclipse.emf.common.util.EList; | |||
| 7 | 7 | ||
| 8 | /** | 8 | /** |
| 9 | * <!-- begin-user-doc --> | 9 | * <!-- begin-user-doc --> |
| 10 | * A representation of the model object '<em><b>Class Interpretation</b></em>'. | 10 | * A representation of the model object '<em><b>Class Definition</b></em>'. |
| 11 | * <!-- end-user-doc --> | 11 | * <!-- end-user-doc --> |
| 12 | * | 12 | * |
| 13 | * <p> | 13 | * <p> |
| 14 | * The following features are supported: | 14 | * The following features are supported: |
| 15 | * </p> | 15 | * </p> |
| 16 | * <ul> | 16 | * <ul> |
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}</li> | 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#isAbstract <em>Abstract</em>}</li> |
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}</li> | 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getName <em>Name</em>}</li> |
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes <em>Supertypes</em>}</li> | 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getSuperclasses <em>Superclasses</em>}</li> |
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt <em>Fielt</em>}</li> | 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getMembers <em>Members</em>}</li> |
| 21 | * </ul> | 21 | * </ul> |
| 22 | * | 22 | * |
| 23 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation() | 23 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassDefinition() |
| 24 | * @model | 24 | * @model |
| 25 | * @generated | 25 | * @generated |
| 26 | */ | 26 | */ |
| 27 | public interface ClassInterpretation extends CDInterpretation | 27 | public interface ClassDefinition extends Statement |
| 28 | { | 28 | { |
| 29 | /** | 29 | /** |
| 30 | * Returns the value of the '<em><b>Abstract</b></em>' attribute. | 30 | * Returns the value of the '<em><b>Abstract</b></em>' attribute. |
| @@ -32,14 +32,14 @@ public interface ClassInterpretation extends CDInterpretation | |||
| 32 | * <!-- end-user-doc --> | 32 | * <!-- end-user-doc --> |
| 33 | * @return the value of the '<em>Abstract</em>' attribute. | 33 | * @return the value of the '<em>Abstract</em>' attribute. |
| 34 | * @see #setAbstract(boolean) | 34 | * @see #setAbstract(boolean) |
| 35 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Abstract() | 35 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassDefinition_Abstract() |
| 36 | * @model | 36 | * @model |
| 37 | * @generated | 37 | * @generated |
| 38 | */ | 38 | */ |
| 39 | boolean isAbstract(); | 39 | boolean isAbstract(); |
| 40 | 40 | ||
| 41 | /** | 41 | /** |
| 42 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}' attribute. | 42 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#isAbstract <em>Abstract</em>}' attribute. |
| 43 | * <!-- begin-user-doc --> | 43 | * <!-- begin-user-doc --> |
| 44 | * <!-- end-user-doc --> | 44 | * <!-- end-user-doc --> |
| 45 | * @param value the new value of the '<em>Abstract</em>' attribute. | 45 | * @param value the new value of the '<em>Abstract</em>' attribute. |
| @@ -49,49 +49,49 @@ public interface ClassInterpretation extends CDInterpretation | |||
| 49 | void setAbstract(boolean value); | 49 | void setAbstract(boolean value); |
| 50 | 50 | ||
| 51 | /** | 51 | /** |
| 52 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | 52 | * Returns the value of the '<em><b>Name</b></em>' attribute. |
| 53 | * <!-- begin-user-doc --> | 53 | * <!-- begin-user-doc --> |
| 54 | * <!-- end-user-doc --> | 54 | * <!-- end-user-doc --> |
| 55 | * @return the value of the '<em>Symbol</em>' containment reference. | 55 | * @return the value of the '<em>Name</em>' attribute. |
| 56 | * @see #setSymbol(ModelSymbol) | 56 | * @see #setName(String) |
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Symbol() | 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassDefinition_Name() |
| 58 | * @model containment="true" | 58 | * @model |
| 59 | * @generated | 59 | * @generated |
| 60 | */ | 60 | */ |
| 61 | ModelSymbol getSymbol(); | 61 | String getName(); |
| 62 | 62 | ||
| 63 | /** | 63 | /** |
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}' containment reference. | 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getName <em>Name</em>}' attribute. |
| 65 | * <!-- begin-user-doc --> | 65 | * <!-- begin-user-doc --> |
| 66 | * <!-- end-user-doc --> | 66 | * <!-- end-user-doc --> |
| 67 | * @param value the new value of the '<em>Symbol</em>' containment reference. | 67 | * @param value the new value of the '<em>Name</em>' attribute. |
| 68 | * @see #getSymbol() | 68 | * @see #getName() |
| 69 | * @generated | 69 | * @generated |
| 70 | */ | 70 | */ |
| 71 | void setSymbol(ModelSymbol value); | 71 | void setName(String value); |
| 72 | 72 | ||
| 73 | /** | 73 | /** |
| 74 | * Returns the value of the '<em><b>Supertypes</b></em>' containment reference list. | 74 | * Returns the value of the '<em><b>Superclasses</b></em>' reference list. |
| 75 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol}. | 75 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement}. |
| 76 | * <!-- begin-user-doc --> | 76 | * <!-- begin-user-doc --> |
| 77 | * <!-- end-user-doc --> | 77 | * <!-- end-user-doc --> |
| 78 | * @return the value of the '<em>Supertypes</em>' containment reference list. | 78 | * @return the value of the '<em>Superclasses</em>' reference list. |
| 79 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Supertypes() | 79 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassDefinition_Superclasses() |
| 80 | * @model containment="true" | 80 | * @model |
| 81 | * @generated | 81 | * @generated |
| 82 | */ | 82 | */ |
| 83 | EList<ModelSymbol> getSupertypes(); | 83 | EList<NamedElement> getSuperclasses(); |
| 84 | 84 | ||
| 85 | /** | 85 | /** |
| 86 | * Returns the value of the '<em><b>Fielt</b></em>' containment reference list. | 86 | * Returns the value of the '<em><b>Members</b></em>' containment reference list. |
| 87 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation}. | 87 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition}. |
| 88 | * <!-- begin-user-doc --> | 88 | * <!-- begin-user-doc --> |
| 89 | * <!-- end-user-doc --> | 89 | * <!-- end-user-doc --> |
| 90 | * @return the value of the '<em>Fielt</em>' containment reference list. | 90 | * @return the value of the '<em>Members</em>' containment reference list. |
| 91 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Fielt() | 91 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassDefinition_Members() |
| 92 | * @model containment="true" | 92 | * @model containment="true" |
| 93 | * @generated | 93 | * @generated |
| 94 | */ | 94 | */ |
| 95 | EList<FieldRelationInterpretation> getFielt(); | 95 | EList<MemberDefinition> getMembers(); |
| 96 | 96 | ||
| 97 | } // ClassInterpretation | 97 | } // ClassDefinition |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Comparison.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Comparison.java new file mode 100644 index 00000000..43e9341a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Comparison.java | |||
| @@ -0,0 +1,96 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Comparison</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getLeft <em>Left</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getOp <em>Op</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getRight <em>Right</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComparison() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface Comparison extends Expression | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Left</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Left</em>' containment reference. | ||
| 32 | * @see #setLeft(Expression) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComparison_Left() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | Expression getLeft(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getLeft <em>Left</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Left</em>' containment reference. | ||
| 44 | * @see #getLeft() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setLeft(Expression value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Op</b></em>' attribute. | ||
| 51 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator}. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Op</em>' attribute. | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 56 | * @see #setOp(BinaryOperator) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComparison_Op() | ||
| 58 | * @model | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | BinaryOperator getOp(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getOp <em>Op</em>}' attribute. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Op</em>' attribute. | ||
| 68 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 69 | * @see #getOp() | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | void setOp(BinaryOperator value); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Returns the value of the '<em><b>Right</b></em>' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Right</em>' containment reference. | ||
| 79 | * @see #setRight(Expression) | ||
| 80 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComparison_Right() | ||
| 81 | * @model containment="true" | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | Expression getRight(); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getRight <em>Right</em>}' containment reference. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param value the new value of the '<em>Right</em>' containment reference. | ||
| 91 | * @see #getRight() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setRight(Expression value); | ||
| 95 | |||
| 96 | } // Comparison | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java deleted file mode 100644 index e266f231..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Complex Object</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * | ||
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComplexObject() | ||
| 15 | * @model | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public interface ComplexObject extends EObject | ||
| 19 | { | ||
| 20 | } // ComplexObject | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Conjunction.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Conjunction.java new file mode 100644 index 00000000..9f1967c0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Conjunction.java | |||
| @@ -0,0 +1,38 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Conjunction</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Conjunction#getChildren <em>Children</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConjunction() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Conjunction extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Children</b></em>' containment reference list. | ||
| 28 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Expression}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Children</em>' containment reference list. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConjunction_Children() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | EList<Expression> getChildren(); | ||
| 37 | |||
| 38 | } // Conjunction | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java deleted file mode 100644 index 9c957def..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java +++ /dev/null | |||
| @@ -1,109 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EObject; | ||
| 9 | |||
| 10 | /** | ||
| 11 | * <!-- begin-user-doc --> | ||
| 12 | * A representation of the model object '<em><b>Constraint</b></em>'. | ||
| 13 | * <!-- end-user-doc --> | ||
| 14 | * | ||
| 15 | * <p> | ||
| 16 | * The following features are supported: | ||
| 17 | * </p> | ||
| 18 | * <ul> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}</li> | ||
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}</li> | ||
| 21 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams <em>Params</em>}</li> | ||
| 22 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}</li> | ||
| 23 | * </ul> | ||
| 24 | * | ||
| 25 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint() | ||
| 26 | * @model | ||
| 27 | * @generated | ||
| 28 | */ | ||
| 29 | public interface Constraint extends EObject | ||
| 30 | { | ||
| 31 | /** | ||
| 32 | * Returns the value of the '<em><b>Polarity</b></em>' containment reference. | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @return the value of the '<em>Polarity</em>' containment reference. | ||
| 36 | * @see #setPolarity(Polarity) | ||
| 37 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Polarity() | ||
| 38 | * @model containment="true" | ||
| 39 | * @generated | ||
| 40 | */ | ||
| 41 | Polarity getPolarity(); | ||
| 42 | |||
| 43 | /** | ||
| 44 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}' containment reference. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @param value the new value of the '<em>Polarity</em>' containment reference. | ||
| 48 | * @see #getPolarity() | ||
| 49 | * @generated | ||
| 50 | */ | ||
| 51 | void setPolarity(Polarity value); | ||
| 52 | |||
| 53 | /** | ||
| 54 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 58 | * @see #setSymbol(ModelSymbol) | ||
| 59 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Symbol() | ||
| 60 | * @model containment="true" | ||
| 61 | * @generated | ||
| 62 | */ | ||
| 63 | ModelSymbol getSymbol(); | ||
| 64 | |||
| 65 | /** | ||
| 66 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}' containment reference. | ||
| 67 | * <!-- begin-user-doc --> | ||
| 68 | * <!-- end-user-doc --> | ||
| 69 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 70 | * @see #getSymbol() | ||
| 71 | * @generated | ||
| 72 | */ | ||
| 73 | void setSymbol(ModelSymbol value); | ||
| 74 | |||
| 75 | /** | ||
| 76 | * Returns the value of the '<em><b>Params</b></em>' containment reference list. | ||
| 77 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Literal}. | ||
| 78 | * <!-- begin-user-doc --> | ||
| 79 | * <!-- end-user-doc --> | ||
| 80 | * @return the value of the '<em>Params</em>' containment reference list. | ||
| 81 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Params() | ||
| 82 | * @model containment="true" | ||
| 83 | * @generated | ||
| 84 | */ | ||
| 85 | EList<Literal> getParams(); | ||
| 86 | |||
| 87 | /** | ||
| 88 | * Returns the value of the '<em><b>Closure Type</b></em>' containment reference. | ||
| 89 | * <!-- begin-user-doc --> | ||
| 90 | * <!-- end-user-doc --> | ||
| 91 | * @return the value of the '<em>Closure Type</em>' containment reference. | ||
| 92 | * @see #setClosureType(ClosureType) | ||
| 93 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_ClosureType() | ||
| 94 | * @model containment="true" | ||
| 95 | * @generated | ||
| 96 | */ | ||
| 97 | ClosureType getClosureType(); | ||
| 98 | |||
| 99 | /** | ||
| 100 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}' containment reference. | ||
| 101 | * <!-- begin-user-doc --> | ||
| 102 | * <!-- end-user-doc --> | ||
| 103 | * @param value the new value of the '<em>Closure Type</em>' containment reference. | ||
| 104 | * @see #getClosureType() | ||
| 105 | * @generated | ||
| 106 | */ | ||
| 107 | void setClosureType(ClosureType value); | ||
| 108 | |||
| 109 | } // Constraint | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Count.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Count.java new file mode 100644 index 00000000..f4b95a1e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Count.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Count</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Count#getBody <em>Body</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCount() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface Count extends Expression | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 30 | * @see #setBody(Expression) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCount_Body() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | Expression getBody(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Count#getBody <em>Body</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 42 | * @see #getBody() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setBody(Expression value); | ||
| 46 | |||
| 47 | } // Count | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java deleted file mode 100644 index 79a0af43..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Data Object</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataObject() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface DataObject extends org.eclipse.viatra.solver.language.solverLanguage.Object, Literal | ||
| 18 | { | ||
| 19 | } // DataObject | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java deleted file mode 100644 index eae8175a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Data Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface DataSymbol extends Symbol | ||
| 18 | { | ||
| 19 | } // DataSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultDefinition.java new file mode 100644 index 00000000..c088f8d7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultDefinition.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Default Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getHead <em>Head</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getRange <em>Range</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultDefinition() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface DefaultDefinition extends Statement | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Head</b></em>' containment reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Head</em>' containment reference. | ||
| 31 | * @see #setHead(Call) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultDefinition_Head() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | Call getHead(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getHead <em>Head</em>}' containment reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Head</em>' containment reference. | ||
| 43 | * @see #getHead() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setHead(Call value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Range</b></em>' containment reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Range</em>' containment reference. | ||
| 53 | * @see #setRange(Expression) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultDefinition_Range() | ||
| 55 | * @model containment="true" | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | Expression getRange(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getRange <em>Range</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Range</em>' containment reference. | ||
| 65 | * @see #getRange() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setRange(Expression value); | ||
| 69 | |||
| 70 | } // DefaultDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java deleted file mode 100644 index 2e9209f6..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Default Interpretation</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface DefaultInterpretation extends Interpretation | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Interpretation</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Interpretation</em>' containment reference. | ||
| 30 | * @see #setInterpretation(BasicInterpretation) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation_Interpretation() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | BasicInterpretation getInterpretation(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Interpretation</em>' containment reference. | ||
| 42 | * @see #getInterpretation() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setInterpretation(BasicInterpretation value); | ||
| 46 | |||
| 47 | } // DefaultInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Disjunction.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Disjunction.java new file mode 100644 index 00000000..724fc04a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Disjunction.java | |||
| @@ -0,0 +1,38 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Disjunction</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Disjunction#getChildren <em>Children</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDisjunction() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Disjunction extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Children</b></em>' containment reference list. | ||
| 28 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Expression}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Children</em>' containment reference list. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDisjunction_Children() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | EList<Expression> getChildren(); | ||
| 37 | |||
| 38 | } // Disjunction | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EmptyIntervalLiteral.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EmptyIntervalLiteral.java new file mode 100644 index 00000000..03f09681 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EmptyIntervalLiteral.java | |||
| @@ -0,0 +1,19 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Empty Interval Literal</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEmptyIntervalLiteral() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface EmptyIntervalLiteral extends Literal | ||
| 18 | { | ||
| 19 | } // EmptyIntervalLiteral | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java deleted file mode 100644 index 8d48c0df..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java +++ /dev/null | |||
| @@ -1,61 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Enum Interpretation</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects <em>Objects</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface EnumInterpretation extends CDInterpretation | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 32 | * @see #setSymbol(ModelSymbol) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Symbol() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | ModelSymbol getSymbol(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 44 | * @see #getSymbol() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setSymbol(ModelSymbol value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Objects</b></em>' containment reference list. | ||
| 51 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject}. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Objects</em>' containment reference list. | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Objects() | ||
| 56 | * @model containment="true" | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | EList<NamedObject> getObjects(); | ||
| 60 | |||
| 61 | } // EnumInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java deleted file mode 100644 index 1edb994f..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Equals Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEqualsSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface EqualsSymbol extends PartialitySymbol | ||
| 18 | { | ||
| 19 | } // EqualsSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java deleted file mode 100644 index bf99bc42..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Error</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getError() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface Error extends TruthValue | ||
| 18 | { | ||
| 19 | } // Error | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactMultiplicity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactMultiplicity.java new file mode 100644 index 00000000..33e88fc4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactMultiplicity.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Exact Multiplicity</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExactMultiplicity() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface ExactMultiplicity extends Multiplicity | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Multiplicity</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Multiplicity</em>' attribute. | ||
| 30 | * @see #setMultiplicity(int) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExactMultiplicity_Multiplicity() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | int getMultiplicity(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity#getMultiplicity <em>Multiplicity</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Multiplicity</em>' attribute. | ||
| 42 | * @see #getMultiplicity() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setMultiplicity(int value); | ||
| 46 | |||
| 47 | } // ExactMultiplicity | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactScopeDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactScopeDefinition.java new file mode 100644 index 00000000..50eb6a00 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExactScopeDefinition.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Exact Scope Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition#getExactScope <em>Exact Scope</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExactScopeDefinition() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface ExactScopeDefinition extends ScopeDefinition | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Exact Scope</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Exact Scope</em>' attribute. | ||
| 30 | * @see #setExactScope(int) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExactScopeDefinition_ExactScope() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | int getExactScope(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition#getExactScope <em>Exact Scope</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Exact Scope</em>' attribute. | ||
| 42 | * @see #getExactScope() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setExactScope(int value); | ||
| 46 | |||
| 47 | } // ExactScopeDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java deleted file mode 100644 index 4dad3295..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Exist Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExistSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface ExistSymbol extends PartialitySymbol | ||
| 18 | { | ||
| 19 | } // ExistSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Expression.java index 5d735fec..1ecd89a5 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Expression.java | |||
| @@ -1,19 +1,19 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | 6 | ||
| 7 | /** | 7 | /** |
| 8 | * <!-- begin-user-doc --> | 8 | * <!-- begin-user-doc --> |
| 9 | * A representation of the model object '<em><b>Negative</b></em>'. | 9 | * A representation of the model object '<em><b>Expression</b></em>'. |
| 10 | * <!-- end-user-doc --> | 10 | * <!-- end-user-doc --> |
| 11 | * | 11 | * |
| 12 | * | 12 | * |
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNegative() | 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExpression() |
| 14 | * @model | 14 | * @model |
| 15 | * @generated | 15 | * @generated |
| 16 | */ | 16 | */ |
| 17 | public interface Negative extends Polarity | 17 | public interface Expression extends Statement |
| 18 | { | 18 | { |
| 19 | } // Negative | 19 | } // Expression |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExpressionArgument.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExpressionArgument.java new file mode 100644 index 00000000..518693a1 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExpressionArgument.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Expression Argument</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument#getBody <em>Body</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExpressionArgument() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface ExpressionArgument extends Argument | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 30 | * @see #setBody(Expression) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExpressionArgument_Body() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | Expression getBody(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument#getBody <em>Body</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 42 | * @see #getBody() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setBody(Expression value); | ||
| 46 | |||
| 47 | } // ExpressionArgument | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternMetricDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternMetricDefinition.java new file mode 100644 index 00000000..086c4b27 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternMetricDefinition.java | |||
| @@ -0,0 +1,73 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Extern Metric Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getType <em>Type</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getHead <em>Head</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExternMetricDefinition() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface ExternMetricDefinition extends Statement | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Type</b></em>' attribute. | ||
| 28 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.MetricType}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Type</em>' attribute. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 33 | * @see #setType(MetricType) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExternMetricDefinition_Type() | ||
| 35 | * @model | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | MetricType getType(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getType <em>Type</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Type</em>' attribute. | ||
| 45 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 46 | * @see #getType() | ||
| 47 | * @generated | ||
| 48 | */ | ||
| 49 | void setType(MetricType value); | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Returns the value of the '<em><b>Head</b></em>' containment reference. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Head</em>' containment reference. | ||
| 56 | * @see #setHead(Call) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExternMetricDefinition_Head() | ||
| 58 | * @model containment="true" | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | Call getHead(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getHead <em>Head</em>}' containment reference. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Head</em>' containment reference. | ||
| 68 | * @see #getHead() | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | void setHead(Call value); | ||
| 72 | |||
| 73 | } // ExternMetricDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternPredicateDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternPredicateDefinition.java new file mode 100644 index 00000000..56e6b645 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExternPredicateDefinition.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Extern Predicate Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition#getHead <em>Head</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExternPredicateDefinition() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface ExternPredicateDefinition extends Statement | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Head</b></em>' containment reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Head</em>' containment reference. | ||
| 30 | * @see #setHead(Call) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExternPredicateDefinition_Head() | ||
| 32 | * @model containment="true" | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | Call getHead(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition#getHead <em>Head</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Head</em>' containment reference. | ||
| 42 | * @see #getHead() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setHead(Call value); | ||
| 46 | |||
| 47 | } // ExternPredicateDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java deleted file mode 100644 index 71947237..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>False</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFalse() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface False extends TruthValue | ||
| 18 | { | ||
| 19 | } // False | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java deleted file mode 100644 index eccf49e0..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java +++ /dev/null | |||
| @@ -1,117 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Field Relation Interpretation</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}</li> | ||
| 21 | * </ul> | ||
| 22 | * | ||
| 23 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation() | ||
| 24 | * @model | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | public interface FieldRelationInterpretation extends EObject | ||
| 28 | { | ||
| 29 | /** | ||
| 30 | * Returns the value of the '<em><b>Containment</b></em>' attribute. | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @return the value of the '<em>Containment</em>' attribute. | ||
| 34 | * @see #setContainment(boolean) | ||
| 35 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Containment() | ||
| 36 | * @model | ||
| 37 | * @generated | ||
| 38 | */ | ||
| 39 | boolean isContainment(); | ||
| 40 | |||
| 41 | /** | ||
| 42 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}' attribute. | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @param value the new value of the '<em>Containment</em>' attribute. | ||
| 46 | * @see #isContainment() | ||
| 47 | * @generated | ||
| 48 | */ | ||
| 49 | void setContainment(boolean value); | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 56 | * @see #setSymbol(ModelSymbol) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Symbol() | ||
| 58 | * @model containment="true" | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | ModelSymbol getSymbol(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}' containment reference. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 68 | * @see #getSymbol() | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | void setSymbol(ModelSymbol value); | ||
| 72 | |||
| 73 | /** | ||
| 74 | * Returns the value of the '<em><b>Multiplicity</b></em>' containment reference. | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @return the value of the '<em>Multiplicity</em>' containment reference. | ||
| 78 | * @see #setMultiplicity(MultiplicityDefinition) | ||
| 79 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Multiplicity() | ||
| 80 | * @model containment="true" | ||
| 81 | * @generated | ||
| 82 | */ | ||
| 83 | MultiplicityDefinition getMultiplicity(); | ||
| 84 | |||
| 85 | /** | ||
| 86 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}' containment reference. | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @param value the new value of the '<em>Multiplicity</em>' containment reference. | ||
| 90 | * @see #getMultiplicity() | ||
| 91 | * @generated | ||
| 92 | */ | ||
| 93 | void setMultiplicity(MultiplicityDefinition value); | ||
| 94 | |||
| 95 | /** | ||
| 96 | * Returns the value of the '<em><b>Target</b></em>' containment reference. | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @return the value of the '<em>Target</em>' containment reference. | ||
| 100 | * @see #setTarget(Symbol) | ||
| 101 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Target() | ||
| 102 | * @model containment="true" | ||
| 103 | * @generated | ||
| 104 | */ | ||
| 105 | Symbol getTarget(); | ||
| 106 | |||
| 107 | /** | ||
| 108 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}' containment reference. | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @param value the new value of the '<em>Target</em>' containment reference. | ||
| 112 | * @see #getTarget() | ||
| 113 | * @generated | ||
| 114 | */ | ||
| 115 | void setTarget(Symbol value); | ||
| 116 | |||
| 117 | } // FieldRelationInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java deleted file mode 100644 index 59ab4278..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java +++ /dev/null | |||
| @@ -1,162 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Global Relation Interpretation</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}</li> | ||
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}</li> | ||
| 21 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}</li> | ||
| 22 | * </ul> | ||
| 23 | * | ||
| 24 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation() | ||
| 25 | * @model | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public interface GlobalRelationInterpretation extends CDInterpretation | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * Returns the value of the '<em><b>Containment</b></em>' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @return the value of the '<em>Containment</em>' attribute. | ||
| 35 | * @see #setContainment(boolean) | ||
| 36 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Containment() | ||
| 37 | * @model | ||
| 38 | * @generated | ||
| 39 | */ | ||
| 40 | boolean isContainment(); | ||
| 41 | |||
| 42 | /** | ||
| 43 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}' attribute. | ||
| 44 | * <!-- begin-user-doc --> | ||
| 45 | * <!-- end-user-doc --> | ||
| 46 | * @param value the new value of the '<em>Containment</em>' attribute. | ||
| 47 | * @see #isContainment() | ||
| 48 | * @generated | ||
| 49 | */ | ||
| 50 | void setContainment(boolean value); | ||
| 51 | |||
| 52 | /** | ||
| 53 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 54 | * <!-- begin-user-doc --> | ||
| 55 | * <!-- end-user-doc --> | ||
| 56 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 57 | * @see #setSymbol(ModelSymbol) | ||
| 58 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Symbol() | ||
| 59 | * @model containment="true" | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | ModelSymbol getSymbol(); | ||
| 63 | |||
| 64 | /** | ||
| 65 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}' containment reference. | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 69 | * @see #getSymbol() | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | void setSymbol(ModelSymbol value); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Returns the value of the '<em><b>Source Multiplicity</b></em>' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Source Multiplicity</em>' containment reference. | ||
| 79 | * @see #setSourceMultiplicity(MultiplicityDefinition) | ||
| 80 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_SourceMultiplicity() | ||
| 81 | * @model containment="true" | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | MultiplicityDefinition getSourceMultiplicity(); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}' containment reference. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param value the new value of the '<em>Source Multiplicity</em>' containment reference. | ||
| 91 | * @see #getSourceMultiplicity() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setSourceMultiplicity(MultiplicityDefinition value); | ||
| 95 | |||
| 96 | /** | ||
| 97 | * Returns the value of the '<em><b>Source</b></em>' containment reference. | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @return the value of the '<em>Source</em>' containment reference. | ||
| 101 | * @see #setSource(Symbol) | ||
| 102 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Source() | ||
| 103 | * @model containment="true" | ||
| 104 | * @generated | ||
| 105 | */ | ||
| 106 | Symbol getSource(); | ||
| 107 | |||
| 108 | /** | ||
| 109 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}' containment reference. | ||
| 110 | * <!-- begin-user-doc --> | ||
| 111 | * <!-- end-user-doc --> | ||
| 112 | * @param value the new value of the '<em>Source</em>' containment reference. | ||
| 113 | * @see #getSource() | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | void setSource(Symbol value); | ||
| 117 | |||
| 118 | /** | ||
| 119 | * Returns the value of the '<em><b>Target Multiplicity</b></em>' containment reference. | ||
| 120 | * <!-- begin-user-doc --> | ||
| 121 | * <!-- end-user-doc --> | ||
| 122 | * @return the value of the '<em>Target Multiplicity</em>' containment reference. | ||
| 123 | * @see #setTargetMultiplicity(MultiplicityDefinition) | ||
| 124 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_TargetMultiplicity() | ||
| 125 | * @model containment="true" | ||
| 126 | * @generated | ||
| 127 | */ | ||
| 128 | MultiplicityDefinition getTargetMultiplicity(); | ||
| 129 | |||
| 130 | /** | ||
| 131 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}' containment reference. | ||
| 132 | * <!-- begin-user-doc --> | ||
| 133 | * <!-- end-user-doc --> | ||
| 134 | * @param value the new value of the '<em>Target Multiplicity</em>' containment reference. | ||
| 135 | * @see #getTargetMultiplicity() | ||
| 136 | * @generated | ||
| 137 | */ | ||
| 138 | void setTargetMultiplicity(MultiplicityDefinition value); | ||
| 139 | |||
| 140 | /** | ||
| 141 | * Returns the value of the '<em><b>Target</b></em>' containment reference. | ||
| 142 | * <!-- begin-user-doc --> | ||
| 143 | * <!-- end-user-doc --> | ||
| 144 | * @return the value of the '<em>Target</em>' containment reference. | ||
| 145 | * @see #setTarget(Symbol) | ||
| 146 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Target() | ||
| 147 | * @model containment="true" | ||
| 148 | * @generated | ||
| 149 | */ | ||
| 150 | Symbol getTarget(); | ||
| 151 | |||
| 152 | /** | ||
| 153 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}' containment reference. | ||
| 154 | * <!-- begin-user-doc --> | ||
| 155 | * <!-- end-user-doc --> | ||
| 156 | * @param value the new value of the '<em>Target</em>' containment reference. | ||
| 157 | * @see #getTarget() | ||
| 158 | * @generated | ||
| 159 | */ | ||
| 160 | void setTarget(Symbol value); | ||
| 161 | |||
| 162 | } // GlobalRelationInterpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IfElse.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IfElse.java new file mode 100644 index 00000000..f08a8420 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IfElse.java | |||
| @@ -0,0 +1,93 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>If Else</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getCondition <em>Condition</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getThen <em>Then</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getElse <em>Else</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIfElse() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface IfElse extends Expression | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Condition</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Condition</em>' containment reference. | ||
| 32 | * @see #setCondition(Expression) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIfElse_Condition() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | Expression getCondition(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getCondition <em>Condition</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Condition</em>' containment reference. | ||
| 44 | * @see #getCondition() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setCondition(Expression value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Then</b></em>' containment reference. | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @return the value of the '<em>Then</em>' containment reference. | ||
| 54 | * @see #setThen(Expression) | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIfElse_Then() | ||
| 56 | * @model containment="true" | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | Expression getThen(); | ||
| 60 | |||
| 61 | /** | ||
| 62 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getThen <em>Then</em>}' containment reference. | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @param value the new value of the '<em>Then</em>' containment reference. | ||
| 66 | * @see #getThen() | ||
| 67 | * @generated | ||
| 68 | */ | ||
| 69 | void setThen(Expression value); | ||
| 70 | |||
| 71 | /** | ||
| 72 | * Returns the value of the '<em><b>Else</b></em>' containment reference. | ||
| 73 | * <!-- begin-user-doc --> | ||
| 74 | * <!-- end-user-doc --> | ||
| 75 | * @return the value of the '<em>Else</em>' containment reference. | ||
| 76 | * @see #setElse(Expression) | ||
| 77 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIfElse_Else() | ||
| 78 | * @model containment="true" | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | Expression getElse(); | ||
| 82 | |||
| 83 | /** | ||
| 84 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getElse <em>Else</em>}' containment reference. | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @param value the new value of the '<em>Else</em>' containment reference. | ||
| 88 | * @see #getElse() | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | void setElse(Expression value); | ||
| 92 | |||
| 93 | } // IfElse | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/InfinityLiteral.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/InfinityLiteral.java new file mode 100644 index 00000000..24e9633b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/InfinityLiteral.java | |||
| @@ -0,0 +1,19 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Infinity Literal</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInfinityLiteral() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface InfinityLiteral extends Literal | ||
| 18 | { | ||
| 19 | } // InfinityLiteral | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java deleted file mode 100644 index d1472499..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Integer Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntegerSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface IntegerSymbol extends DataSymbol | ||
| 18 | { | ||
| 19 | } // IntegerSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java deleted file mode 100644 index 56541016..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Interpretation</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterpretation() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface Interpretation extends Statement | ||
| 18 | { | ||
| 19 | } // Interpretation | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interval.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interval.java new file mode 100644 index 00000000..3431ef8b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interval.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Interval</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getLowerBound <em>Lower Bound</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getUpperBound <em>Upper Bound</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterval() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Interval extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Lower Bound</b></em>' containment reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Lower Bound</em>' containment reference. | ||
| 31 | * @see #setLowerBound(Expression) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterval_LowerBound() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | Expression getLowerBound(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getLowerBound <em>Lower Bound</em>}' containment reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Lower Bound</em>' containment reference. | ||
| 43 | * @see #getLowerBound() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setLowerBound(Expression value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Upper Bound</b></em>' containment reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Upper Bound</em>' containment reference. | ||
| 53 | * @see #setUpperBound(Expression) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterval_UpperBound() | ||
| 55 | * @model containment="true" | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | Expression getUpperBound(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getUpperBound <em>Upper Bound</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Upper Bound</em>' containment reference. | ||
| 65 | * @see #getUpperBound() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setUpperBound(Expression value); | ||
| 69 | |||
| 70 | } // Interval | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java deleted file mode 100644 index eca04f1e..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Irreflexive Closure</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIrreflexiveClosure() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface IrreflexiveClosure extends ClosureType | ||
| 18 | { | ||
| 19 | } // IrreflexiveClosure | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java index 259abe8c..67d4e64f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java | |||
| @@ -1,9 +1,8 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | 6 | ||
| 8 | /** | 7 | /** |
| 9 | * <!-- begin-user-doc --> | 8 | * <!-- begin-user-doc --> |
| @@ -15,6 +14,6 @@ import org.eclipse.emf.ecore.EObject; | |||
| 15 | * @model | 14 | * @model |
| 16 | * @generated | 15 | * @generated |
| 17 | */ | 16 | */ |
| 18 | public interface Literal extends EObject | 17 | public interface Literal extends Expression |
| 19 | { | 18 | { |
| 20 | } // Literal | 19 | } // Literal |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LogicLiteral.java index 1a42b0c3..b3eb1523 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LogicLiteral.java | |||
| @@ -1,47 +1,50 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | 6 | ||
| 7 | /** | 7 | /** |
| 8 | * <!-- begin-user-doc --> | 8 | * <!-- begin-user-doc --> |
| 9 | * A representation of the model object '<em><b>Int Object</b></em>'. | 9 | * A representation of the model object '<em><b>Logic Literal</b></em>'. |
| 10 | * <!-- end-user-doc --> | 10 | * <!-- end-user-doc --> |
| 11 | * | 11 | * |
| 12 | * <p> | 12 | * <p> |
| 13 | * The following features are supported: | 13 | * The following features are supported: |
| 14 | * </p> | 14 | * </p> |
| 15 | * <ul> | 15 | * <ul> |
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}</li> | 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral#getValue <em>Value</em>}</li> |
| 17 | * </ul> | 17 | * </ul> |
| 18 | * | 18 | * |
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject() | 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLogicLiteral() |
| 20 | * @model | 20 | * @model |
| 21 | * @generated | 21 | * @generated |
| 22 | */ | 22 | */ |
| 23 | public interface IntObject extends DataObject | 23 | public interface LogicLiteral extends Literal |
| 24 | { | 24 | { |
| 25 | /** | 25 | /** |
| 26 | * Returns the value of the '<em><b>Value</b></em>' attribute. | 26 | * Returns the value of the '<em><b>Value</b></em>' attribute. |
| 27 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.LogicValue}. | ||
| 27 | * <!-- begin-user-doc --> | 28 | * <!-- begin-user-doc --> |
| 28 | * <!-- end-user-doc --> | 29 | * <!-- end-user-doc --> |
| 29 | * @return the value of the '<em>Value</em>' attribute. | 30 | * @return the value of the '<em>Value</em>' attribute. |
| 30 | * @see #setValue(int) | 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicValue |
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject_Value() | 32 | * @see #setValue(LogicValue) |
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLogicLiteral_Value() | ||
| 32 | * @model | 34 | * @model |
| 33 | * @generated | 35 | * @generated |
| 34 | */ | 36 | */ |
| 35 | int getValue(); | 37 | LogicValue getValue(); |
| 36 | 38 | ||
| 37 | /** | 39 | /** |
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}' attribute. | 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral#getValue <em>Value</em>}' attribute. |
| 39 | * <!-- begin-user-doc --> | 41 | * <!-- begin-user-doc --> |
| 40 | * <!-- end-user-doc --> | 42 | * <!-- end-user-doc --> |
| 41 | * @param value the new value of the '<em>Value</em>' attribute. | 43 | * @param value the new value of the '<em>Value</em>' attribute. |
| 44 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicValue | ||
| 42 | * @see #getValue() | 45 | * @see #getValue() |
| 43 | * @generated | 46 | * @generated |
| 44 | */ | 47 | */ |
| 45 | void setValue(int value); | 48 | void setValue(LogicValue value); |
| 46 | 49 | ||
| 47 | } // IntObject | 50 | } // LogicLiteral |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LogicValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LogicValue.java new file mode 100644 index 00000000..61be81f7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LogicValue.java | |||
| @@ -0,0 +1,271 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Logic Value</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLogicValue() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum LogicValue implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>TRUE</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #TRUE_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | TRUE(0, "TRUE", "true"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>FALSE</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #FALSE_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | FALSE(1, "FALSE", "false"), | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>UNKNOWN</b></em>' literal object. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #UNKNOWN_VALUE | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | UNKNOWN(2, "UNKNOWN", "unknown"), | ||
| 52 | |||
| 53 | /** | ||
| 54 | * The '<em><b>ERROR</b></em>' literal object. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @see #ERROR_VALUE | ||
| 58 | * @generated | ||
| 59 | * @ordered | ||
| 60 | */ | ||
| 61 | ERROR(3, "ERROR", "error"); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * The '<em><b>TRUE</b></em>' literal value. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @see #TRUE | ||
| 68 | * @model literal="true" | ||
| 69 | * @generated | ||
| 70 | * @ordered | ||
| 71 | */ | ||
| 72 | public static final int TRUE_VALUE = 0; | ||
| 73 | |||
| 74 | /** | ||
| 75 | * The '<em><b>FALSE</b></em>' literal value. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @see #FALSE | ||
| 79 | * @model literal="false" | ||
| 80 | * @generated | ||
| 81 | * @ordered | ||
| 82 | */ | ||
| 83 | public static final int FALSE_VALUE = 1; | ||
| 84 | |||
| 85 | /** | ||
| 86 | * The '<em><b>UNKNOWN</b></em>' literal value. | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @see #UNKNOWN | ||
| 90 | * @model literal="unknown" | ||
| 91 | * @generated | ||
| 92 | * @ordered | ||
| 93 | */ | ||
| 94 | public static final int UNKNOWN_VALUE = 2; | ||
| 95 | |||
| 96 | /** | ||
| 97 | * The '<em><b>ERROR</b></em>' literal value. | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @see #ERROR | ||
| 101 | * @model literal="error" | ||
| 102 | * @generated | ||
| 103 | * @ordered | ||
| 104 | */ | ||
| 105 | public static final int ERROR_VALUE = 3; | ||
| 106 | |||
| 107 | /** | ||
| 108 | * An array of all the '<em><b>Logic Value</b></em>' enumerators. | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | private static final LogicValue[] VALUES_ARRAY = | ||
| 114 | new LogicValue[] | ||
| 115 | { | ||
| 116 | TRUE, | ||
| 117 | FALSE, | ||
| 118 | UNKNOWN, | ||
| 119 | ERROR, | ||
| 120 | }; | ||
| 121 | |||
| 122 | /** | ||
| 123 | * A public read-only list of all the '<em><b>Logic Value</b></em>' enumerators. | ||
| 124 | * <!-- begin-user-doc --> | ||
| 125 | * <!-- end-user-doc --> | ||
| 126 | * @generated | ||
| 127 | */ | ||
| 128 | public static final List<LogicValue> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 129 | |||
| 130 | /** | ||
| 131 | * Returns the '<em><b>Logic Value</b></em>' literal with the specified literal value. | ||
| 132 | * <!-- begin-user-doc --> | ||
| 133 | * <!-- end-user-doc --> | ||
| 134 | * @param literal the literal. | ||
| 135 | * @return the matching enumerator or <code>null</code>. | ||
| 136 | * @generated | ||
| 137 | */ | ||
| 138 | public static LogicValue get(String literal) | ||
| 139 | { | ||
| 140 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 141 | { | ||
| 142 | LogicValue result = VALUES_ARRAY[i]; | ||
| 143 | if (result.toString().equals(literal)) | ||
| 144 | { | ||
| 145 | return result; | ||
| 146 | } | ||
| 147 | } | ||
| 148 | return null; | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * Returns the '<em><b>Logic Value</b></em>' literal with the specified name. | ||
| 153 | * <!-- begin-user-doc --> | ||
| 154 | * <!-- end-user-doc --> | ||
| 155 | * @param name the name. | ||
| 156 | * @return the matching enumerator or <code>null</code>. | ||
| 157 | * @generated | ||
| 158 | */ | ||
| 159 | public static LogicValue getByName(String name) | ||
| 160 | { | ||
| 161 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 162 | { | ||
| 163 | LogicValue result = VALUES_ARRAY[i]; | ||
| 164 | if (result.getName().equals(name)) | ||
| 165 | { | ||
| 166 | return result; | ||
| 167 | } | ||
| 168 | } | ||
| 169 | return null; | ||
| 170 | } | ||
| 171 | |||
| 172 | /** | ||
| 173 | * Returns the '<em><b>Logic Value</b></em>' literal with the specified integer value. | ||
| 174 | * <!-- begin-user-doc --> | ||
| 175 | * <!-- end-user-doc --> | ||
| 176 | * @param value the integer value. | ||
| 177 | * @return the matching enumerator or <code>null</code>. | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | public static LogicValue get(int value) | ||
| 181 | { | ||
| 182 | switch (value) | ||
| 183 | { | ||
| 184 | case TRUE_VALUE: return TRUE; | ||
| 185 | case FALSE_VALUE: return FALSE; | ||
| 186 | case UNKNOWN_VALUE: return UNKNOWN; | ||
| 187 | case ERROR_VALUE: return ERROR; | ||
| 188 | } | ||
| 189 | return null; | ||
| 190 | } | ||
| 191 | |||
| 192 | /** | ||
| 193 | * <!-- begin-user-doc --> | ||
| 194 | * <!-- end-user-doc --> | ||
| 195 | * @generated | ||
| 196 | */ | ||
| 197 | private final int value; | ||
| 198 | |||
| 199 | /** | ||
| 200 | * <!-- begin-user-doc --> | ||
| 201 | * <!-- end-user-doc --> | ||
| 202 | * @generated | ||
| 203 | */ | ||
| 204 | private final String name; | ||
| 205 | |||
| 206 | /** | ||
| 207 | * <!-- begin-user-doc --> | ||
| 208 | * <!-- end-user-doc --> | ||
| 209 | * @generated | ||
| 210 | */ | ||
| 211 | private final String literal; | ||
| 212 | |||
| 213 | /** | ||
| 214 | * Only this class can construct instances. | ||
| 215 | * <!-- begin-user-doc --> | ||
| 216 | * <!-- end-user-doc --> | ||
| 217 | * @generated | ||
| 218 | */ | ||
| 219 | private LogicValue(int value, String name, String literal) | ||
| 220 | { | ||
| 221 | this.value = value; | ||
| 222 | this.name = name; | ||
| 223 | this.literal = literal; | ||
| 224 | } | ||
| 225 | |||
| 226 | /** | ||
| 227 | * <!-- begin-user-doc --> | ||
| 228 | * <!-- end-user-doc --> | ||
| 229 | * @generated | ||
| 230 | */ | ||
| 231 | @Override | ||
| 232 | public int getValue() | ||
| 233 | { | ||
| 234 | return value; | ||
| 235 | } | ||
| 236 | |||
| 237 | /** | ||
| 238 | * <!-- begin-user-doc --> | ||
| 239 | * <!-- end-user-doc --> | ||
| 240 | * @generated | ||
| 241 | */ | ||
| 242 | @Override | ||
| 243 | public String getName() | ||
| 244 | { | ||
| 245 | return name; | ||
| 246 | } | ||
| 247 | |||
| 248 | /** | ||
| 249 | * <!-- begin-user-doc --> | ||
| 250 | * <!-- end-user-doc --> | ||
| 251 | * @generated | ||
| 252 | */ | ||
| 253 | @Override | ||
| 254 | public String getLiteral() | ||
| 255 | { | ||
| 256 | return literal; | ||
| 257 | } | ||
| 258 | |||
| 259 | /** | ||
| 260 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | @Override | ||
| 266 | public String toString() | ||
| 267 | { | ||
| 268 | return literal; | ||
| 269 | } | ||
| 270 | |||
| 271 | } //LogicValue | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LowerBoundedScopeDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LowerBoundedScopeDefinition.java new file mode 100644 index 00000000..57edcfda --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/LowerBoundedScopeDefinition.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Lower Bounded Scope Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLowerBoundedScopeDefinition() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface LowerBoundedScopeDefinition extends ScopeDefinition | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Lower Bound</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Lower Bound</em>' attribute. | ||
| 30 | * @see #setLowerBound(int) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLowerBoundedScopeDefinition_LowerBound() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | int getLowerBound(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Lower Bound</em>' attribute. | ||
| 42 | * @see #getLowerBound() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setLowerBound(int value); | ||
| 46 | |||
| 47 | } // LowerBoundedScopeDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ManyMultiplicity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ManyMultiplicity.java new file mode 100644 index 00000000..4a667d4a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ManyMultiplicity.java | |||
| @@ -0,0 +1,19 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Many Multiplicity</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getManyMultiplicity() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface ManyMultiplicity extends Multiplicity | ||
| 18 | { | ||
| 19 | } // ManyMultiplicity | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MemberDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MemberDefinition.java new file mode 100644 index 00000000..3b413c11 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MemberDefinition.java | |||
| @@ -0,0 +1,140 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Member Definition</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#isContainment <em>Containment</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getType <em>Type</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getName <em>Name</em>}</li> | ||
| 21 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getOpposite <em>Opposite</em>}</li> | ||
| 22 | * </ul> | ||
| 23 | * | ||
| 24 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition() | ||
| 25 | * @model | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public interface MemberDefinition extends EObject | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * Returns the value of the '<em><b>Containment</b></em>' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @return the value of the '<em>Containment</em>' attribute. | ||
| 35 | * @see #setContainment(boolean) | ||
| 36 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition_Containment() | ||
| 37 | * @model | ||
| 38 | * @generated | ||
| 39 | */ | ||
| 40 | boolean isContainment(); | ||
| 41 | |||
| 42 | /** | ||
| 43 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#isContainment <em>Containment</em>}' attribute. | ||
| 44 | * <!-- begin-user-doc --> | ||
| 45 | * <!-- end-user-doc --> | ||
| 46 | * @param value the new value of the '<em>Containment</em>' attribute. | ||
| 47 | * @see #isContainment() | ||
| 48 | * @generated | ||
| 49 | */ | ||
| 50 | void setContainment(boolean value); | ||
| 51 | |||
| 52 | /** | ||
| 53 | * Returns the value of the '<em><b>Type</b></em>' reference. | ||
| 54 | * <!-- begin-user-doc --> | ||
| 55 | * <!-- end-user-doc --> | ||
| 56 | * @return the value of the '<em>Type</em>' reference. | ||
| 57 | * @see #setType(NamedElement) | ||
| 58 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition_Type() | ||
| 59 | * @model | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | NamedElement getType(); | ||
| 63 | |||
| 64 | /** | ||
| 65 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getType <em>Type</em>}' reference. | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @param value the new value of the '<em>Type</em>' reference. | ||
| 69 | * @see #getType() | ||
| 70 | * @generated | ||
| 71 | */ | ||
| 72 | void setType(NamedElement value); | ||
| 73 | |||
| 74 | /** | ||
| 75 | * Returns the value of the '<em><b>Multiplicity</b></em>' containment reference. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Multiplicity</em>' containment reference. | ||
| 79 | * @see #setMultiplicity(Multiplicity) | ||
| 80 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition_Multiplicity() | ||
| 81 | * @model containment="true" | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | Multiplicity getMultiplicity(); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getMultiplicity <em>Multiplicity</em>}' containment reference. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param value the new value of the '<em>Multiplicity</em>' containment reference. | ||
| 91 | * @see #getMultiplicity() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setMultiplicity(Multiplicity value); | ||
| 95 | |||
| 96 | /** | ||
| 97 | * Returns the value of the '<em><b>Name</b></em>' attribute. | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @return the value of the '<em>Name</em>' attribute. | ||
| 101 | * @see #setName(String) | ||
| 102 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition_Name() | ||
| 103 | * @model | ||
| 104 | * @generated | ||
| 105 | */ | ||
| 106 | String getName(); | ||
| 107 | |||
| 108 | /** | ||
| 109 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getName <em>Name</em>}' attribute. | ||
| 110 | * <!-- begin-user-doc --> | ||
| 111 | * <!-- end-user-doc --> | ||
| 112 | * @param value the new value of the '<em>Name</em>' attribute. | ||
| 113 | * @see #getName() | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | void setName(String value); | ||
| 117 | |||
| 118 | /** | ||
| 119 | * Returns the value of the '<em><b>Opposite</b></em>' reference. | ||
| 120 | * <!-- begin-user-doc --> | ||
| 121 | * <!-- end-user-doc --> | ||
| 122 | * @return the value of the '<em>Opposite</em>' reference. | ||
| 123 | * @see #setOpposite(NamedElement) | ||
| 124 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMemberDefinition_Opposite() | ||
| 125 | * @model | ||
| 126 | * @generated | ||
| 127 | */ | ||
| 128 | NamedElement getOpposite(); | ||
| 129 | |||
| 130 | /** | ||
| 131 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getOpposite <em>Opposite</em>}' reference. | ||
| 132 | * <!-- begin-user-doc --> | ||
| 133 | * <!-- end-user-doc --> | ||
| 134 | * @param value the new value of the '<em>Opposite</em>' reference. | ||
| 135 | * @see #getOpposite() | ||
| 136 | * @generated | ||
| 137 | */ | ||
| 138 | void setOpposite(NamedElement value); | ||
| 139 | |||
| 140 | } // MemberDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricDefinition.java new file mode 100644 index 00000000..a35ab60c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricDefinition.java | |||
| @@ -0,0 +1,96 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Metric Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getHead <em>Head</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getBody <em>Body</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getType <em>Type</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMetricDefinition() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface MetricDefinition extends Statement | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Head</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Head</em>' containment reference. | ||
| 32 | * @see #setHead(Expression) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMetricDefinition_Head() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | Expression getHead(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getHead <em>Head</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Head</em>' containment reference. | ||
| 44 | * @see #getHead() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setHead(Expression value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 54 | * @see #setBody(Expression) | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMetricDefinition_Body() | ||
| 56 | * @model containment="true" | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | Expression getBody(); | ||
| 60 | |||
| 61 | /** | ||
| 62 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getBody <em>Body</em>}' containment reference. | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 66 | * @see #getBody() | ||
| 67 | * @generated | ||
| 68 | */ | ||
| 69 | void setBody(Expression value); | ||
| 70 | |||
| 71 | /** | ||
| 72 | * Returns the value of the '<em><b>Type</b></em>' attribute. | ||
| 73 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.MetricType}. | ||
| 74 | * <!-- begin-user-doc --> | ||
| 75 | * <!-- end-user-doc --> | ||
| 76 | * @return the value of the '<em>Type</em>' attribute. | ||
| 77 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 78 | * @see #setType(MetricType) | ||
| 79 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMetricDefinition_Type() | ||
| 80 | * @model | ||
| 81 | * @generated | ||
| 82 | */ | ||
| 83 | MetricType getType(); | ||
| 84 | |||
| 85 | /** | ||
| 86 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getType <em>Type</em>}' attribute. | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @param value the new value of the '<em>Type</em>' attribute. | ||
| 90 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 91 | * @see #getType() | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | void setType(MetricType value); | ||
| 95 | |||
| 96 | } // MetricDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricType.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricType.java new file mode 100644 index 00000000..0aa6a805 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MetricType.java | |||
| @@ -0,0 +1,225 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Metric Type</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMetricType() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum MetricType implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>INT</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #INT_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | INT(0, "INT", "int"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>REAL</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #REAL_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | REAL(1, "REAL", "real"); | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>INT</b></em>' literal value. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #INT | ||
| 48 | * @model literal="int" | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | public static final int INT_VALUE = 0; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * The '<em><b>REAL</b></em>' literal value. | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @see #REAL | ||
| 59 | * @model literal="real" | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | public static final int REAL_VALUE = 1; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * An array of all the '<em><b>Metric Type</b></em>' enumerators. | ||
| 67 | * <!-- begin-user-doc --> | ||
| 68 | * <!-- end-user-doc --> | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | private static final MetricType[] VALUES_ARRAY = | ||
| 72 | new MetricType[] | ||
| 73 | { | ||
| 74 | INT, | ||
| 75 | REAL, | ||
| 76 | }; | ||
| 77 | |||
| 78 | /** | ||
| 79 | * A public read-only list of all the '<em><b>Metric Type</b></em>' enumerators. | ||
| 80 | * <!-- begin-user-doc --> | ||
| 81 | * <!-- end-user-doc --> | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | public static final List<MetricType> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Returns the '<em><b>Metric Type</b></em>' literal with the specified literal value. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param literal the literal. | ||
| 91 | * @return the matching enumerator or <code>null</code>. | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | public static MetricType get(String literal) | ||
| 95 | { | ||
| 96 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 97 | { | ||
| 98 | MetricType result = VALUES_ARRAY[i]; | ||
| 99 | if (result.toString().equals(literal)) | ||
| 100 | { | ||
| 101 | return result; | ||
| 102 | } | ||
| 103 | } | ||
| 104 | return null; | ||
| 105 | } | ||
| 106 | |||
| 107 | /** | ||
| 108 | * Returns the '<em><b>Metric Type</b></em>' literal with the specified name. | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @param name the name. | ||
| 112 | * @return the matching enumerator or <code>null</code>. | ||
| 113 | * @generated | ||
| 114 | */ | ||
| 115 | public static MetricType getByName(String name) | ||
| 116 | { | ||
| 117 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 118 | { | ||
| 119 | MetricType result = VALUES_ARRAY[i]; | ||
| 120 | if (result.getName().equals(name)) | ||
| 121 | { | ||
| 122 | return result; | ||
| 123 | } | ||
| 124 | } | ||
| 125 | return null; | ||
| 126 | } | ||
| 127 | |||
| 128 | /** | ||
| 129 | * Returns the '<em><b>Metric Type</b></em>' literal with the specified integer value. | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @param value the integer value. | ||
| 133 | * @return the matching enumerator or <code>null</code>. | ||
| 134 | * @generated | ||
| 135 | */ | ||
| 136 | public static MetricType get(int value) | ||
| 137 | { | ||
| 138 | switch (value) | ||
| 139 | { | ||
| 140 | case INT_VALUE: return INT; | ||
| 141 | case REAL_VALUE: return REAL; | ||
| 142 | } | ||
| 143 | return null; | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | private final int value; | ||
| 152 | |||
| 153 | /** | ||
| 154 | * <!-- begin-user-doc --> | ||
| 155 | * <!-- end-user-doc --> | ||
| 156 | * @generated | ||
| 157 | */ | ||
| 158 | private final String name; | ||
| 159 | |||
| 160 | /** | ||
| 161 | * <!-- begin-user-doc --> | ||
| 162 | * <!-- end-user-doc --> | ||
| 163 | * @generated | ||
| 164 | */ | ||
| 165 | private final String literal; | ||
| 166 | |||
| 167 | /** | ||
| 168 | * Only this class can construct instances. | ||
| 169 | * <!-- begin-user-doc --> | ||
| 170 | * <!-- end-user-doc --> | ||
| 171 | * @generated | ||
| 172 | */ | ||
| 173 | private MetricType(int value, String name, String literal) | ||
| 174 | { | ||
| 175 | this.value = value; | ||
| 176 | this.name = name; | ||
| 177 | this.literal = literal; | ||
| 178 | } | ||
| 179 | |||
| 180 | /** | ||
| 181 | * <!-- begin-user-doc --> | ||
| 182 | * <!-- end-user-doc --> | ||
| 183 | * @generated | ||
| 184 | */ | ||
| 185 | @Override | ||
| 186 | public int getValue() | ||
| 187 | { | ||
| 188 | return value; | ||
| 189 | } | ||
| 190 | |||
| 191 | /** | ||
| 192 | * <!-- begin-user-doc --> | ||
| 193 | * <!-- end-user-doc --> | ||
| 194 | * @generated | ||
| 195 | */ | ||
| 196 | @Override | ||
| 197 | public String getName() | ||
| 198 | { | ||
| 199 | return name; | ||
| 200 | } | ||
| 201 | |||
| 202 | /** | ||
| 203 | * <!-- begin-user-doc --> | ||
| 204 | * <!-- end-user-doc --> | ||
| 205 | * @generated | ||
| 206 | */ | ||
| 207 | @Override | ||
| 208 | public String getLiteral() | ||
| 209 | { | ||
| 210 | return literal; | ||
| 211 | } | ||
| 212 | |||
| 213 | /** | ||
| 214 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 215 | * <!-- begin-user-doc --> | ||
| 216 | * <!-- end-user-doc --> | ||
| 217 | * @generated | ||
| 218 | */ | ||
| 219 | @Override | ||
| 220 | public String toString() | ||
| 221 | { | ||
| 222 | return literal; | ||
| 223 | } | ||
| 224 | |||
| 225 | } //MetricType | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Multiplicity.java index f9d8dc28..1cbfadd6 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Multiplicity.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -7,14 +7,14 @@ import org.eclipse.emf.ecore.EObject; | |||
| 7 | 7 | ||
| 8 | /** | 8 | /** |
| 9 | * <!-- begin-user-doc --> | 9 | * <!-- begin-user-doc --> |
| 10 | * A representation of the model object '<em><b>Closure Type</b></em>'. | 10 | * A representation of the model object '<em><b>Multiplicity</b></em>'. |
| 11 | * <!-- end-user-doc --> | 11 | * <!-- end-user-doc --> |
| 12 | * | 12 | * |
| 13 | * | 13 | * |
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClosureType() | 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicity() |
| 15 | * @model | 15 | * @model |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public interface ClosureType extends EObject | 18 | public interface Multiplicity extends EObject |
| 19 | { | 19 | { |
| 20 | } // ClosureType | 20 | } // Multiplicity |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java deleted file mode 100644 index 9b4def59..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java +++ /dev/null | |||
| @@ -1,94 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Multiplicity Definition</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}</li> | ||
| 20 | * </ul> | ||
| 21 | * | ||
| 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition() | ||
| 23 | * @model | ||
| 24 | * @generated | ||
| 25 | */ | ||
| 26 | public interface MultiplicityDefinition extends EObject | ||
| 27 | { | ||
| 28 | /** | ||
| 29 | * Returns the value of the '<em><b>Lower</b></em>' attribute. | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @return the value of the '<em>Lower</em>' attribute. | ||
| 33 | * @see #setLower(int) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Lower() | ||
| 35 | * @model | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | int getLower(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Lower</em>' attribute. | ||
| 45 | * @see #getLower() | ||
| 46 | * @generated | ||
| 47 | */ | ||
| 48 | void setLower(int value); | ||
| 49 | |||
| 50 | /** | ||
| 51 | * Returns the value of the '<em><b>Upper</b></em>' attribute. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Upper</em>' attribute. | ||
| 55 | * @see #setUpper(int) | ||
| 56 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Upper() | ||
| 57 | * @model | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | int getUpper(); | ||
| 61 | |||
| 62 | /** | ||
| 63 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}' attribute. | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @param value the new value of the '<em>Upper</em>' attribute. | ||
| 67 | * @see #getUpper() | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | void setUpper(int value); | ||
| 71 | |||
| 72 | /** | ||
| 73 | * Returns the value of the '<em><b>Unlimited Upper</b></em>' attribute. | ||
| 74 | * <!-- begin-user-doc --> | ||
| 75 | * <!-- end-user-doc --> | ||
| 76 | * @return the value of the '<em>Unlimited Upper</em>' attribute. | ||
| 77 | * @see #setUnlimitedUpper(boolean) | ||
| 78 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_UnlimitedUpper() | ||
| 79 | * @model | ||
| 80 | * @generated | ||
| 81 | */ | ||
| 82 | boolean isUnlimitedUpper(); | ||
| 83 | |||
| 84 | /** | ||
| 85 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}' attribute. | ||
| 86 | * <!-- begin-user-doc --> | ||
| 87 | * <!-- end-user-doc --> | ||
| 88 | * @param value the new value of the '<em>Unlimited Upper</em>' attribute. | ||
| 89 | * @see #isUnlimitedUpper() | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | void setUnlimitedUpper(boolean value); | ||
| 93 | |||
| 94 | } // MultiplicityDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedElement.java index 0d91b791..0372da14 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedElement.java | |||
| @@ -1,26 +1,27 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 6 | 7 | ||
| 7 | /** | 8 | /** |
| 8 | * <!-- begin-user-doc --> | 9 | * <!-- begin-user-doc --> |
| 9 | * A representation of the model object '<em><b>Model Symbol</b></em>'. | 10 | * A representation of the model object '<em><b>Named Element</b></em>'. |
| 10 | * <!-- end-user-doc --> | 11 | * <!-- end-user-doc --> |
| 11 | * | 12 | * |
| 12 | * <p> | 13 | * <p> |
| 13 | * The following features are supported: | 14 | * The following features are supported: |
| 14 | * </p> | 15 | * </p> |
| 15 | * <ul> | 16 | * <ul> |
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}</li> | 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement#getName <em>Name</em>}</li> |
| 17 | * </ul> | 18 | * </ul> |
| 18 | * | 19 | * |
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol() | 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedElement() |
| 20 | * @model | 21 | * @model |
| 21 | * @generated | 22 | * @generated |
| 22 | */ | 23 | */ |
| 23 | public interface ModelSymbol extends Symbol | 24 | public interface NamedElement extends EObject |
| 24 | { | 25 | { |
| 25 | /** | 26 | /** |
| 26 | * Returns the value of the '<em><b>Name</b></em>' attribute. | 27 | * Returns the value of the '<em><b>Name</b></em>' attribute. |
| @@ -28,14 +29,14 @@ public interface ModelSymbol extends Symbol | |||
| 28 | * <!-- end-user-doc --> | 29 | * <!-- end-user-doc --> |
| 29 | * @return the value of the '<em>Name</em>' attribute. | 30 | * @return the value of the '<em>Name</em>' attribute. |
| 30 | * @see #setName(String) | 31 | * @see #setName(String) |
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol_Name() | 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedElement_Name() |
| 32 | * @model | 33 | * @model |
| 33 | * @generated | 34 | * @generated |
| 34 | */ | 35 | */ |
| 35 | String getName(); | 36 | String getName(); |
| 36 | 37 | ||
| 37 | /** | 38 | /** |
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}' attribute. | 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement#getName <em>Name</em>}' attribute. |
| 39 | * <!-- begin-user-doc --> | 40 | * <!-- begin-user-doc --> |
| 40 | * <!-- end-user-doc --> | 41 | * <!-- end-user-doc --> |
| 41 | * @param value the new value of the '<em>Name</em>' attribute. | 42 | * @param value the new value of the '<em>Name</em>' attribute. |
| @@ -44,4 +45,4 @@ public interface ModelSymbol extends Symbol | |||
| 44 | */ | 45 | */ |
| 45 | void setName(String value); | 46 | void setName(String value); |
| 46 | 47 | ||
| 47 | } // ModelSymbol | 48 | } // NamedElement |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java deleted file mode 100644 index b44ef060..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Named Object</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface NamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object, Literal | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Name</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Name</em>' attribute. | ||
| 30 | * @see #setName(String) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject_Name() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | String getName(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Name</em>' attribute. | ||
| 42 | * @see #getName() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setName(String value); | ||
| 46 | |||
| 47 | } // NamedObject | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NumericLiteral.java index 12e8be3e..9e30d508 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NumericLiteral.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -7,21 +7,21 @@ import java.math.BigDecimal; | |||
| 7 | 7 | ||
| 8 | /** | 8 | /** |
| 9 | * <!-- begin-user-doc --> | 9 | * <!-- begin-user-doc --> |
| 10 | * A representation of the model object '<em><b>Real Object</b></em>'. | 10 | * A representation of the model object '<em><b>Numeric Literal</b></em>'. |
| 11 | * <!-- end-user-doc --> | 11 | * <!-- end-user-doc --> |
| 12 | * | 12 | * |
| 13 | * <p> | 13 | * <p> |
| 14 | * The following features are supported: | 14 | * The following features are supported: |
| 15 | * </p> | 15 | * </p> |
| 16 | * <ul> | 16 | * <ul> |
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}</li> | 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral#getValue <em>Value</em>}</li> |
| 18 | * </ul> | 18 | * </ul> |
| 19 | * | 19 | * |
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject() | 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNumericLiteral() |
| 21 | * @model | 21 | * @model |
| 22 | * @generated | 22 | * @generated |
| 23 | */ | 23 | */ |
| 24 | public interface RealObject extends DataObject | 24 | public interface NumericLiteral extends Literal |
| 25 | { | 25 | { |
| 26 | /** | 26 | /** |
| 27 | * Returns the value of the '<em><b>Value</b></em>' attribute. | 27 | * Returns the value of the '<em><b>Value</b></em>' attribute. |
| @@ -29,14 +29,14 @@ public interface RealObject extends DataObject | |||
| 29 | * <!-- end-user-doc --> | 29 | * <!-- end-user-doc --> |
| 30 | * @return the value of the '<em>Value</em>' attribute. | 30 | * @return the value of the '<em>Value</em>' attribute. |
| 31 | * @see #setValue(BigDecimal) | 31 | * @see #setValue(BigDecimal) |
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject_Value() | 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNumericLiteral_Value() |
| 33 | * @model | 33 | * @model |
| 34 | * @generated | 34 | * @generated |
| 35 | */ | 35 | */ |
| 36 | BigDecimal getValue(); | 36 | BigDecimal getValue(); |
| 37 | 37 | ||
| 38 | /** | 38 | /** |
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}' attribute. | 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral#getValue <em>Value</em>}' attribute. |
| 40 | * <!-- begin-user-doc --> | 40 | * <!-- begin-user-doc --> |
| 41 | * <!-- end-user-doc --> | 41 | * <!-- end-user-doc --> |
| 42 | * @param value the new value of the '<em>Value</em>' attribute. | 42 | * @param value the new value of the '<em>Value</em>' attribute. |
| @@ -45,4 +45,4 @@ public interface RealObject extends DataObject | |||
| 45 | */ | 45 | */ |
| 46 | void setValue(BigDecimal value); | 46 | void setValue(BigDecimal value); |
| 47 | 47 | ||
| 48 | } // RealObject | 48 | } // NumericLiteral |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java deleted file mode 100644 index 908ae5a6..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Object</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObject() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface Object extends ComplexObject | ||
| 18 | { | ||
| 19 | } // Object | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveDefinition.java new file mode 100644 index 00000000..417a389c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveDefinition.java | |||
| @@ -0,0 +1,73 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Objective Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getKind <em>Kind</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getObjective <em>Objective</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObjectiveDefinition() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface ObjectiveDefinition extends Statement | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Kind</b></em>' attribute. | ||
| 28 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Kind</em>' attribute. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind | ||
| 33 | * @see #setKind(ObjectiveKind) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObjectiveDefinition_Kind() | ||
| 35 | * @model | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | ObjectiveKind getKind(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getKind <em>Kind</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Kind</em>' attribute. | ||
| 45 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind | ||
| 46 | * @see #getKind() | ||
| 47 | * @generated | ||
| 48 | */ | ||
| 49 | void setKind(ObjectiveKind value); | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Returns the value of the '<em><b>Objective</b></em>' containment reference. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Objective</em>' containment reference. | ||
| 56 | * @see #setObjective(Expression) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObjectiveDefinition_Objective() | ||
| 58 | * @model containment="true" | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | Expression getObjective(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getObjective <em>Objective</em>}' containment reference. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Objective</em>' containment reference. | ||
| 68 | * @see #getObjective() | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | void setObjective(Expression value); | ||
| 72 | |||
| 73 | } // ObjectiveDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveKind.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveKind.java new file mode 100644 index 00000000..d3a4f626 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ObjectiveKind.java | |||
| @@ -0,0 +1,225 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Objective Kind</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObjectiveKind() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum ObjectiveKind implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>MINIMIZE</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #MINIMIZE_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | MINIMIZE(0, "MINIMIZE", "minimize"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>MAXIMIZE</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #MAXIMIZE_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | MAXIMIZE(1, "MAXIMIZE", "maximize"); | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>MINIMIZE</b></em>' literal value. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #MINIMIZE | ||
| 48 | * @model literal="minimize" | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | public static final int MINIMIZE_VALUE = 0; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * The '<em><b>MAXIMIZE</b></em>' literal value. | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @see #MAXIMIZE | ||
| 59 | * @model literal="maximize" | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | public static final int MAXIMIZE_VALUE = 1; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * An array of all the '<em><b>Objective Kind</b></em>' enumerators. | ||
| 67 | * <!-- begin-user-doc --> | ||
| 68 | * <!-- end-user-doc --> | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | private static final ObjectiveKind[] VALUES_ARRAY = | ||
| 72 | new ObjectiveKind[] | ||
| 73 | { | ||
| 74 | MINIMIZE, | ||
| 75 | MAXIMIZE, | ||
| 76 | }; | ||
| 77 | |||
| 78 | /** | ||
| 79 | * A public read-only list of all the '<em><b>Objective Kind</b></em>' enumerators. | ||
| 80 | * <!-- begin-user-doc --> | ||
| 81 | * <!-- end-user-doc --> | ||
| 82 | * @generated | ||
| 83 | */ | ||
| 84 | public static final List<ObjectiveKind> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 85 | |||
| 86 | /** | ||
| 87 | * Returns the '<em><b>Objective Kind</b></em>' literal with the specified literal value. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @param literal the literal. | ||
| 91 | * @return the matching enumerator or <code>null</code>. | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | public static ObjectiveKind get(String literal) | ||
| 95 | { | ||
| 96 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 97 | { | ||
| 98 | ObjectiveKind result = VALUES_ARRAY[i]; | ||
| 99 | if (result.toString().equals(literal)) | ||
| 100 | { | ||
| 101 | return result; | ||
| 102 | } | ||
| 103 | } | ||
| 104 | return null; | ||
| 105 | } | ||
| 106 | |||
| 107 | /** | ||
| 108 | * Returns the '<em><b>Objective Kind</b></em>' literal with the specified name. | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @param name the name. | ||
| 112 | * @return the matching enumerator or <code>null</code>. | ||
| 113 | * @generated | ||
| 114 | */ | ||
| 115 | public static ObjectiveKind getByName(String name) | ||
| 116 | { | ||
| 117 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 118 | { | ||
| 119 | ObjectiveKind result = VALUES_ARRAY[i]; | ||
| 120 | if (result.getName().equals(name)) | ||
| 121 | { | ||
| 122 | return result; | ||
| 123 | } | ||
| 124 | } | ||
| 125 | return null; | ||
| 126 | } | ||
| 127 | |||
| 128 | /** | ||
| 129 | * Returns the '<em><b>Objective Kind</b></em>' literal with the specified integer value. | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @param value the integer value. | ||
| 133 | * @return the matching enumerator or <code>null</code>. | ||
| 134 | * @generated | ||
| 135 | */ | ||
| 136 | public static ObjectiveKind get(int value) | ||
| 137 | { | ||
| 138 | switch (value) | ||
| 139 | { | ||
| 140 | case MINIMIZE_VALUE: return MINIMIZE; | ||
| 141 | case MAXIMIZE_VALUE: return MAXIMIZE; | ||
| 142 | } | ||
| 143 | return null; | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | private final int value; | ||
| 152 | |||
| 153 | /** | ||
| 154 | * <!-- begin-user-doc --> | ||
| 155 | * <!-- end-user-doc --> | ||
| 156 | * @generated | ||
| 157 | */ | ||
| 158 | private final String name; | ||
| 159 | |||
| 160 | /** | ||
| 161 | * <!-- begin-user-doc --> | ||
| 162 | * <!-- end-user-doc --> | ||
| 163 | * @generated | ||
| 164 | */ | ||
| 165 | private final String literal; | ||
| 166 | |||
| 167 | /** | ||
| 168 | * Only this class can construct instances. | ||
| 169 | * <!-- begin-user-doc --> | ||
| 170 | * <!-- end-user-doc --> | ||
| 171 | * @generated | ||
| 172 | */ | ||
| 173 | private ObjectiveKind(int value, String name, String literal) | ||
| 174 | { | ||
| 175 | this.value = value; | ||
| 176 | this.name = name; | ||
| 177 | this.literal = literal; | ||
| 178 | } | ||
| 179 | |||
| 180 | /** | ||
| 181 | * <!-- begin-user-doc --> | ||
| 182 | * <!-- end-user-doc --> | ||
| 183 | * @generated | ||
| 184 | */ | ||
| 185 | @Override | ||
| 186 | public int getValue() | ||
| 187 | { | ||
| 188 | return value; | ||
| 189 | } | ||
| 190 | |||
| 191 | /** | ||
| 192 | * <!-- begin-user-doc --> | ||
| 193 | * <!-- end-user-doc --> | ||
| 194 | * @generated | ||
| 195 | */ | ||
| 196 | @Override | ||
| 197 | public String getName() | ||
| 198 | { | ||
| 199 | return name; | ||
| 200 | } | ||
| 201 | |||
| 202 | /** | ||
| 203 | * <!-- begin-user-doc --> | ||
| 204 | * <!-- end-user-doc --> | ||
| 205 | * @generated | ||
| 206 | */ | ||
| 207 | @Override | ||
| 208 | public String getLiteral() | ||
| 209 | { | ||
| 210 | return literal; | ||
| 211 | } | ||
| 212 | |||
| 213 | /** | ||
| 214 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 215 | * <!-- begin-user-doc --> | ||
| 216 | * <!-- end-user-doc --> | ||
| 217 | * @generated | ||
| 218 | */ | ||
| 219 | @Override | ||
| 220 | public String toString() | ||
| 221 | { | ||
| 222 | return literal; | ||
| 223 | } | ||
| 224 | |||
| 225 | } //ObjectiveKind | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java deleted file mode 100644 index e4ef1c28..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java +++ /dev/null | |||
| @@ -1,71 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Parameter</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}</li> | ||
| 19 | * </ul> | ||
| 20 | * | ||
| 21 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter() | ||
| 22 | * @model | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | public interface Parameter extends EObject | ||
| 26 | { | ||
| 27 | /** | ||
| 28 | * Returns the value of the '<em><b>Variable</b></em>' containment reference. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Variable</em>' containment reference. | ||
| 32 | * @see #setVariable(Variable) | ||
| 33 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Variable() | ||
| 34 | * @model containment="true" | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | Variable getVariable(); | ||
| 38 | |||
| 39 | /** | ||
| 40 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}' containment reference. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @param value the new value of the '<em>Variable</em>' containment reference. | ||
| 44 | * @see #getVariable() | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | void setVariable(Variable value); | ||
| 48 | |||
| 49 | /** | ||
| 50 | * Returns the value of the '<em><b>Type</b></em>' containment reference. | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @return the value of the '<em>Type</em>' containment reference. | ||
| 54 | * @see #setType(Symbol) | ||
| 55 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Type() | ||
| 56 | * @model containment="true" | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | Symbol getType(); | ||
| 60 | |||
| 61 | /** | ||
| 62 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}' containment reference. | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @param value the new value of the '<em>Type</em>' containment reference. | ||
| 66 | * @see #getType() | ||
| 67 | * @generated | ||
| 68 | */ | ||
| 69 | void setType(Symbol value); | ||
| 70 | |||
| 71 | } // Parameter | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java deleted file mode 100644 index a4331248..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Partiality Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPartialitySymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface PartialitySymbol extends Symbol | ||
| 18 | { | ||
| 19 | } // PartialitySymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java deleted file mode 100644 index 075a865f..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Positive</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPositive() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface Positive extends Polarity | ||
| 18 | { | ||
| 19 | } // Positive | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java deleted file mode 100644 index 7892fd57..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java +++ /dev/null | |||
| @@ -1,97 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Predicate</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#isIsError <em>Is Error</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getSymbol <em>Symbol</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters <em>Parameters</em>}</li> | ||
| 20 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies <em>Bodies</em>}</li> | ||
| 21 | * </ul> | ||
| 22 | * | ||
| 23 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate() | ||
| 24 | * @model | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | public interface Predicate extends Statement | ||
| 28 | { | ||
| 29 | /** | ||
| 30 | * Returns the value of the '<em><b>Is Error</b></em>' attribute. | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @return the value of the '<em>Is Error</em>' attribute. | ||
| 34 | * @see #setIsError(boolean) | ||
| 35 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_IsError() | ||
| 36 | * @model | ||
| 37 | * @generated | ||
| 38 | */ | ||
| 39 | boolean isIsError(); | ||
| 40 | |||
| 41 | /** | ||
| 42 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#isIsError <em>Is Error</em>}' attribute. | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @param value the new value of the '<em>Is Error</em>' attribute. | ||
| 46 | * @see #isIsError() | ||
| 47 | * @generated | ||
| 48 | */ | ||
| 49 | void setIsError(boolean value); | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Returns the value of the '<em><b>Symbol</b></em>' containment reference. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Symbol</em>' containment reference. | ||
| 56 | * @see #setSymbol(ModelSymbol) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Symbol() | ||
| 58 | * @model containment="true" | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | ModelSymbol getSymbol(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getSymbol <em>Symbol</em>}' containment reference. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Symbol</em>' containment reference. | ||
| 68 | * @see #getSymbol() | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | void setSymbol(ModelSymbol value); | ||
| 72 | |||
| 73 | /** | ||
| 74 | * Returns the value of the '<em><b>Parameters</b></em>' containment reference list. | ||
| 75 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Parameter}. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @return the value of the '<em>Parameters</em>' containment reference list. | ||
| 79 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Parameters() | ||
| 80 | * @model containment="true" | ||
| 81 | * @generated | ||
| 82 | */ | ||
| 83 | EList<Parameter> getParameters(); | ||
| 84 | |||
| 85 | /** | ||
| 86 | * Returns the value of the '<em><b>Bodies</b></em>' containment reference list. | ||
| 87 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody}. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @return the value of the '<em>Bodies</em>' containment reference list. | ||
| 91 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Bodies() | ||
| 92 | * @model containment="true" | ||
| 93 | * @generated | ||
| 94 | */ | ||
| 95 | EList<PatternBody> getBodies(); | ||
| 96 | |||
| 97 | } // Predicate | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateDefinition.java new file mode 100644 index 00000000..256cb5ac --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateDefinition.java | |||
| @@ -0,0 +1,116 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Predicate Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getHead <em>Head</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getBody <em>Body</em>}</li> | ||
| 18 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isFunctional <em>Functional</em>}</li> | ||
| 19 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isError <em>Error</em>}</li> | ||
| 20 | * </ul> | ||
| 21 | * | ||
| 22 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateDefinition() | ||
| 23 | * @model | ||
| 24 | * @generated | ||
| 25 | */ | ||
| 26 | public interface PredicateDefinition extends Statement | ||
| 27 | { | ||
| 28 | /** | ||
| 29 | * Returns the value of the '<em><b>Head</b></em>' containment reference. | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @return the value of the '<em>Head</em>' containment reference. | ||
| 33 | * @see #setHead(Expression) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateDefinition_Head() | ||
| 35 | * @model containment="true" | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | Expression getHead(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getHead <em>Head</em>}' containment reference. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Head</em>' containment reference. | ||
| 45 | * @see #getHead() | ||
| 46 | * @generated | ||
| 47 | */ | ||
| 48 | void setHead(Expression value); | ||
| 49 | |||
| 50 | /** | ||
| 51 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 55 | * @see #setBody(Expression) | ||
| 56 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateDefinition_Body() | ||
| 57 | * @model containment="true" | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | Expression getBody(); | ||
| 61 | |||
| 62 | /** | ||
| 63 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getBody <em>Body</em>}' containment reference. | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 67 | * @see #getBody() | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | void setBody(Expression value); | ||
| 71 | |||
| 72 | /** | ||
| 73 | * Returns the value of the '<em><b>Functional</b></em>' attribute. | ||
| 74 | * <!-- begin-user-doc --> | ||
| 75 | * <!-- end-user-doc --> | ||
| 76 | * @return the value of the '<em>Functional</em>' attribute. | ||
| 77 | * @see #setFunctional(boolean) | ||
| 78 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateDefinition_Functional() | ||
| 79 | * @model | ||
| 80 | * @generated | ||
| 81 | */ | ||
| 82 | boolean isFunctional(); | ||
| 83 | |||
| 84 | /** | ||
| 85 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isFunctional <em>Functional</em>}' attribute. | ||
| 86 | * <!-- begin-user-doc --> | ||
| 87 | * <!-- end-user-doc --> | ||
| 88 | * @param value the new value of the '<em>Functional</em>' attribute. | ||
| 89 | * @see #isFunctional() | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | void setFunctional(boolean value); | ||
| 93 | |||
| 94 | /** | ||
| 95 | * Returns the value of the '<em><b>Error</b></em>' attribute. | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @return the value of the '<em>Error</em>' attribute. | ||
| 99 | * @see #setError(boolean) | ||
| 100 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateDefinition_Error() | ||
| 101 | * @model | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | boolean isError(); | ||
| 105 | |||
| 106 | /** | ||
| 107 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isError <em>Error</em>}' attribute. | ||
| 108 | * <!-- begin-user-doc --> | ||
| 109 | * <!-- end-user-doc --> | ||
| 110 | * @param value the new value of the '<em>Error</em>' attribute. | ||
| 111 | * @see #isError() | ||
| 112 | * @generated | ||
| 113 | */ | ||
| 114 | void setError(boolean value); | ||
| 115 | |||
| 116 | } // PredicateDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java index 91967617..2383bf18 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java deleted file mode 100644 index 06dd35fc..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Real Symbol</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealSymbol() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface RealSymbol extends DataSymbol | ||
| 18 | { | ||
| 19 | } // RealSymbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Reference.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Reference.java new file mode 100644 index 00000000..6adb6a9d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Reference.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Reference</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Reference#getReferred <em>Referred</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getReference() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface Reference extends Expression | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Referred</b></em>' reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Referred</em>' reference. | ||
| 30 | * @see #setReferred(NamedElement) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getReference_Referred() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | NamedElement getReferred(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Reference#getReferred <em>Referred</em>}' reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Referred</em>' reference. | ||
| 42 | * @see #getReferred() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setReferred(NamedElement value); | ||
| 46 | |||
| 47 | } // Reference | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java deleted file mode 100644 index 3eb30271..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Reflexive Closure</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getReflexiveClosure() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface ReflexiveClosure extends ClosureType | ||
| 18 | { | ||
| 19 | } // ReflexiveClosure | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ScopeDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ScopeDefinition.java new file mode 100644 index 00000000..42fb6513 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ScopeDefinition.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Scope Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition#getType <em>Type</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getScopeDefinition() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface ScopeDefinition extends Statement | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Type</b></em>' reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Type</em>' reference. | ||
| 30 | * @see #setType(NamedElement) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getScopeDefinition_Type() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | NamedElement getType(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition#getType <em>Type</em>}' reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Type</em>' reference. | ||
| 42 | * @see #getType() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setType(NamedElement value); | ||
| 46 | |||
| 47 | } // ScopeDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java index c5d4cbff..f6e293b9 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| @@ -42,454 +42,409 @@ public interface SolverLanguageFactory extends EFactory | |||
| 42 | Statement createStatement(); | 42 | Statement createStatement(); |
| 43 | 43 | ||
| 44 | /** | 44 | /** |
| 45 | * Returns a new object of class '<em>Boolean Value</em>'. | 45 | * Returns a new object of class '<em>Predicate Definition</em>'. |
| 46 | * <!-- begin-user-doc --> | 46 | * <!-- begin-user-doc --> |
| 47 | * <!-- end-user-doc --> | 47 | * <!-- end-user-doc --> |
| 48 | * @return a new object of class '<em>Boolean Value</em>'. | 48 | * @return a new object of class '<em>Predicate Definition</em>'. |
| 49 | * @generated | 49 | * @generated |
| 50 | */ | 50 | */ |
| 51 | BooleanValue createBooleanValue(); | 51 | PredicateDefinition createPredicateDefinition(); |
| 52 | 52 | ||
| 53 | /** | 53 | /** |
| 54 | * Returns a new object of class '<em>Truth Value</em>'. | 54 | * Returns a new object of class '<em>Unnamed Error Prediate Definition</em>'. |
| 55 | * <!-- begin-user-doc --> | 55 | * <!-- begin-user-doc --> |
| 56 | * <!-- end-user-doc --> | 56 | * <!-- end-user-doc --> |
| 57 | * @return a new object of class '<em>Truth Value</em>'. | 57 | * @return a new object of class '<em>Unnamed Error Prediate Definition</em>'. |
| 58 | * @generated | 58 | * @generated |
| 59 | */ | 59 | */ |
| 60 | TruthValue createTruthValue(); | 60 | UnnamedErrorPrediateDefinition createUnnamedErrorPrediateDefinition(); |
| 61 | 61 | ||
| 62 | /** | 62 | /** |
| 63 | * Returns a new object of class '<em>Interpretation</em>'. | 63 | * Returns a new object of class '<em>Default Definition</em>'. |
| 64 | * <!-- begin-user-doc --> | 64 | * <!-- begin-user-doc --> |
| 65 | * <!-- end-user-doc --> | 65 | * <!-- end-user-doc --> |
| 66 | * @return a new object of class '<em>Interpretation</em>'. | 66 | * @return a new object of class '<em>Default Definition</em>'. |
| 67 | * @generated | 67 | * @generated |
| 68 | */ | 68 | */ |
| 69 | Interpretation createInterpretation(); | 69 | DefaultDefinition createDefaultDefinition(); |
| 70 | 70 | ||
| 71 | /** | 71 | /** |
| 72 | * Returns a new object of class '<em>Basic Interpretation</em>'. | 72 | * Returns a new object of class '<em>Extern Predicate Definition</em>'. |
| 73 | * <!-- begin-user-doc --> | 73 | * <!-- begin-user-doc --> |
| 74 | * <!-- end-user-doc --> | 74 | * <!-- end-user-doc --> |
| 75 | * @return a new object of class '<em>Basic Interpretation</em>'. | 75 | * @return a new object of class '<em>Extern Predicate Definition</em>'. |
| 76 | * @generated | 76 | * @generated |
| 77 | */ | 77 | */ |
| 78 | BasicInterpretation createBasicInterpretation(); | 78 | ExternPredicateDefinition createExternPredicateDefinition(); |
| 79 | 79 | ||
| 80 | /** | 80 | /** |
| 81 | * Returns a new object of class '<em>Symbol</em>'. | 81 | * Returns a new object of class '<em>Metric Definition</em>'. |
| 82 | * <!-- begin-user-doc --> | 82 | * <!-- begin-user-doc --> |
| 83 | * <!-- end-user-doc --> | 83 | * <!-- end-user-doc --> |
| 84 | * @return a new object of class '<em>Symbol</em>'. | 84 | * @return a new object of class '<em>Metric Definition</em>'. |
| 85 | * @generated | 85 | * @generated |
| 86 | */ | 86 | */ |
| 87 | Symbol createSymbol(); | 87 | MetricDefinition createMetricDefinition(); |
| 88 | 88 | ||
| 89 | /** | 89 | /** |
| 90 | * Returns a new object of class '<em>Model Symbol</em>'. | 90 | * Returns a new object of class '<em>Extern Metric Definition</em>'. |
| 91 | * <!-- begin-user-doc --> | 91 | * <!-- begin-user-doc --> |
| 92 | * <!-- end-user-doc --> | 92 | * <!-- end-user-doc --> |
| 93 | * @return a new object of class '<em>Model Symbol</em>'. | 93 | * @return a new object of class '<em>Extern Metric Definition</em>'. |
| 94 | * @generated | 94 | * @generated |
| 95 | */ | 95 | */ |
| 96 | ModelSymbol createModelSymbol(); | 96 | ExternMetricDefinition createExternMetricDefinition(); |
| 97 | 97 | ||
| 98 | /** | 98 | /** |
| 99 | * Returns a new object of class '<em>Partiality Symbol</em>'. | 99 | * Returns a new object of class '<em>Expression</em>'. |
| 100 | * <!-- begin-user-doc --> | 100 | * <!-- begin-user-doc --> |
| 101 | * <!-- end-user-doc --> | 101 | * <!-- end-user-doc --> |
| 102 | * @return a new object of class '<em>Partiality Symbol</em>'. | 102 | * @return a new object of class '<em>Expression</em>'. |
| 103 | * @generated | 103 | * @generated |
| 104 | */ | 104 | */ |
| 105 | PartialitySymbol createPartialitySymbol(); | 105 | Expression createExpression(); |
| 106 | 106 | ||
| 107 | /** | 107 | /** |
| 108 | * Returns a new object of class '<em>Exist Symbol</em>'. | 108 | * Returns a new object of class '<em>If Else</em>'. |
| 109 | * <!-- begin-user-doc --> | 109 | * <!-- begin-user-doc --> |
| 110 | * <!-- end-user-doc --> | 110 | * <!-- end-user-doc --> |
| 111 | * @return a new object of class '<em>Exist Symbol</em>'. | 111 | * @return a new object of class '<em>If Else</em>'. |
| 112 | * @generated | 112 | * @generated |
| 113 | */ | 113 | */ |
| 114 | ExistSymbol createExistSymbol(); | 114 | IfElse createIfElse(); |
| 115 | 115 | ||
| 116 | /** | 116 | /** |
| 117 | * Returns a new object of class '<em>Equals Symbol</em>'. | 117 | * Returns a new object of class '<em>Case</em>'. |
| 118 | * <!-- begin-user-doc --> | 118 | * <!-- begin-user-doc --> |
| 119 | * <!-- end-user-doc --> | 119 | * <!-- end-user-doc --> |
| 120 | * @return a new object of class '<em>Equals Symbol</em>'. | 120 | * @return a new object of class '<em>Case</em>'. |
| 121 | * @generated | 121 | * @generated |
| 122 | */ | 122 | */ |
| 123 | EqualsSymbol createEqualsSymbol(); | 123 | Case createCase(); |
| 124 | 124 | ||
| 125 | /** | 125 | /** |
| 126 | * Returns a new object of class '<em>Data Symbol</em>'. | 126 | * Returns a new object of class '<em>Count</em>'. |
| 127 | * <!-- begin-user-doc --> | 127 | * <!-- begin-user-doc --> |
| 128 | * <!-- end-user-doc --> | 128 | * <!-- end-user-doc --> |
| 129 | * @return a new object of class '<em>Data Symbol</em>'. | 129 | * @return a new object of class '<em>Count</em>'. |
| 130 | * @generated | 130 | * @generated |
| 131 | */ | 131 | */ |
| 132 | DataSymbol createDataSymbol(); | 132 | Count createCount(); |
| 133 | 133 | ||
| 134 | /** | 134 | /** |
| 135 | * Returns a new object of class '<em>Boolean Symbol</em>'. | 135 | * Returns a new object of class '<em>Aggregation</em>'. |
| 136 | * <!-- begin-user-doc --> | 136 | * <!-- begin-user-doc --> |
| 137 | * <!-- end-user-doc --> | 137 | * <!-- end-user-doc --> |
| 138 | * @return a new object of class '<em>Boolean Symbol</em>'. | 138 | * @return a new object of class '<em>Aggregation</em>'. |
| 139 | * @generated | 139 | * @generated |
| 140 | */ | 140 | */ |
| 141 | BooleanSymbol createBooleanSymbol(); | 141 | Aggregation createAggregation(); |
| 142 | 142 | ||
| 143 | /** | 143 | /** |
| 144 | * Returns a new object of class '<em>Integer Symbol</em>'. | 144 | * Returns a new object of class '<em>Call</em>'. |
| 145 | * <!-- begin-user-doc --> | 145 | * <!-- begin-user-doc --> |
| 146 | * <!-- end-user-doc --> | 146 | * <!-- end-user-doc --> |
| 147 | * @return a new object of class '<em>Integer Symbol</em>'. | 147 | * @return a new object of class '<em>Call</em>'. |
| 148 | * @generated | 148 | * @generated |
| 149 | */ | 149 | */ |
| 150 | IntegerSymbol createIntegerSymbol(); | 150 | Call createCall(); |
| 151 | 151 | ||
| 152 | /** | 152 | /** |
| 153 | * Returns a new object of class '<em>Real Symbol</em>'. | 153 | * Returns a new object of class '<em>Argument List</em>'. |
| 154 | * <!-- begin-user-doc --> | 154 | * <!-- begin-user-doc --> |
| 155 | * <!-- end-user-doc --> | 155 | * <!-- end-user-doc --> |
| 156 | * @return a new object of class '<em>Real Symbol</em>'. | 156 | * @return a new object of class '<em>Argument List</em>'. |
| 157 | * @generated | 157 | * @generated |
| 158 | */ | 158 | */ |
| 159 | RealSymbol createRealSymbol(); | 159 | ArgumentList createArgumentList(); |
| 160 | 160 | ||
| 161 | /** | 161 | /** |
| 162 | * Returns a new object of class '<em>String Symbol</em>'. | 162 | * Returns a new object of class '<em>Argument</em>'. |
| 163 | * <!-- begin-user-doc --> | 163 | * <!-- begin-user-doc --> |
| 164 | * <!-- end-user-doc --> | 164 | * <!-- end-user-doc --> |
| 165 | * @return a new object of class '<em>String Symbol</em>'. | 165 | * @return a new object of class '<em>Argument</em>'. |
| 166 | * @generated | 166 | * @generated |
| 167 | */ | 167 | */ |
| 168 | StringSymbol createStringSymbol(); | 168 | Argument createArgument(); |
| 169 | 169 | ||
| 170 | /** | 170 | /** |
| 171 | * Returns a new object of class '<em>Complex Object</em>'. | 171 | * Returns a new object of class '<em>Expression Argument</em>'. |
| 172 | * <!-- begin-user-doc --> | 172 | * <!-- begin-user-doc --> |
| 173 | * <!-- end-user-doc --> | 173 | * <!-- end-user-doc --> |
| 174 | * @return a new object of class '<em>Complex Object</em>'. | 174 | * @return a new object of class '<em>Expression Argument</em>'. |
| 175 | * @generated | 175 | * @generated |
| 176 | */ | 176 | */ |
| 177 | ComplexObject createComplexObject(); | 177 | ExpressionArgument createExpressionArgument(); |
| 178 | 178 | ||
| 179 | /** | 179 | /** |
| 180 | * Returns a new object of class '<em>Object</em>'. | 180 | * Returns a new object of class '<em>Star Argument</em>'. |
| 181 | * <!-- begin-user-doc --> | 181 | * <!-- begin-user-doc --> |
| 182 | * <!-- end-user-doc --> | 182 | * <!-- end-user-doc --> |
| 183 | * @return a new object of class '<em>Object</em>'. | 183 | * @return a new object of class '<em>Star Argument</em>'. |
| 184 | * @generated | 184 | * @generated |
| 185 | */ | 185 | */ |
| 186 | Object createObject(); | 186 | StarArgument createStarArgument(); |
| 187 | 187 | ||
| 188 | /** | 188 | /** |
| 189 | * Returns a new object of class '<em>Named Object</em>'. | 189 | * Returns a new object of class '<em>Typed Argument</em>'. |
| 190 | * <!-- begin-user-doc --> | 190 | * <!-- begin-user-doc --> |
| 191 | * <!-- end-user-doc --> | 191 | * <!-- end-user-doc --> |
| 192 | * @return a new object of class '<em>Named Object</em>'. | 192 | * @return a new object of class '<em>Typed Argument</em>'. |
| 193 | * @generated | 193 | * @generated |
| 194 | */ | 194 | */ |
| 195 | NamedObject createNamedObject(); | 195 | TypedArgument createTypedArgument(); |
| 196 | 196 | ||
| 197 | /** | 197 | /** |
| 198 | * Returns a new object of class '<em>Unnamed Object</em>'. | 198 | * Returns a new object of class '<em>Typed Star Argument</em>'. |
| 199 | * <!-- begin-user-doc --> | 199 | * <!-- begin-user-doc --> |
| 200 | * <!-- end-user-doc --> | 200 | * <!-- end-user-doc --> |
| 201 | * @return a new object of class '<em>Unnamed Object</em>'. | 201 | * @return a new object of class '<em>Typed Star Argument</em>'. |
| 202 | * @generated | 202 | * @generated |
| 203 | */ | 203 | */ |
| 204 | UnnamedObject createUnnamedObject(); | 204 | TypedStarArgument createTypedStarArgument(); |
| 205 | 205 | ||
| 206 | /** | 206 | /** |
| 207 | * Returns a new object of class '<em>Data Object</em>'. | 207 | * Returns a new object of class '<em>Reference</em>'. |
| 208 | * <!-- begin-user-doc --> | 208 | * <!-- begin-user-doc --> |
| 209 | * <!-- end-user-doc --> | 209 | * <!-- end-user-doc --> |
| 210 | * @return a new object of class '<em>Data Object</em>'. | 210 | * @return a new object of class '<em>Reference</em>'. |
| 211 | * @generated | 211 | * @generated |
| 212 | */ | 212 | */ |
| 213 | DataObject createDataObject(); | 213 | Reference createReference(); |
| 214 | 214 | ||
| 215 | /** | 215 | /** |
| 216 | * Returns a new object of class '<em>Boolean Object</em>'. | 216 | * Returns a new object of class '<em>Interval</em>'. |
| 217 | * <!-- begin-user-doc --> | 217 | * <!-- begin-user-doc --> |
| 218 | * <!-- end-user-doc --> | 218 | * <!-- end-user-doc --> |
| 219 | * @return a new object of class '<em>Boolean Object</em>'. | 219 | * @return a new object of class '<em>Interval</em>'. |
| 220 | * @generated | 220 | * @generated |
| 221 | */ | 221 | */ |
| 222 | BooleanObject createBooleanObject(); | 222 | Interval createInterval(); |
| 223 | 223 | ||
| 224 | /** | 224 | /** |
| 225 | * Returns a new object of class '<em>Int Object</em>'. | 225 | * Returns a new object of class '<em>Literal</em>'. |
| 226 | * <!-- begin-user-doc --> | ||
| 227 | * <!-- end-user-doc --> | ||
| 228 | * @return a new object of class '<em>Int Object</em>'. | ||
| 229 | * @generated | ||
| 230 | */ | ||
| 231 | IntObject createIntObject(); | ||
| 232 | |||
| 233 | /** | ||
| 234 | * Returns a new object of class '<em>Real Object</em>'. | ||
| 235 | * <!-- begin-user-doc --> | ||
| 236 | * <!-- end-user-doc --> | ||
| 237 | * @return a new object of class '<em>Real Object</em>'. | ||
| 238 | * @generated | ||
| 239 | */ | ||
| 240 | RealObject createRealObject(); | ||
| 241 | |||
| 242 | /** | ||
| 243 | * Returns a new object of class '<em>String Object</em>'. | ||
| 244 | * <!-- begin-user-doc --> | ||
| 245 | * <!-- end-user-doc --> | ||
| 246 | * @return a new object of class '<em>String Object</em>'. | ||
| 247 | * @generated | ||
| 248 | */ | ||
| 249 | StringObject createStringObject(); | ||
| 250 | |||
| 251 | /** | ||
| 252 | * Returns a new object of class '<em>Predicate</em>'. | ||
| 253 | * <!-- begin-user-doc --> | ||
| 254 | * <!-- end-user-doc --> | ||
| 255 | * @return a new object of class '<em>Predicate</em>'. | ||
| 256 | * @generated | ||
| 257 | */ | ||
| 258 | Predicate createPredicate(); | ||
| 259 | |||
| 260 | /** | ||
| 261 | * Returns a new object of class '<em>Parameter</em>'. | ||
| 262 | * <!-- begin-user-doc --> | ||
| 263 | * <!-- end-user-doc --> | ||
| 264 | * @return a new object of class '<em>Parameter</em>'. | ||
| 265 | * @generated | ||
| 266 | */ | ||
| 267 | Parameter createParameter(); | ||
| 268 | |||
| 269 | /** | ||
| 270 | * Returns a new object of class '<em>Pattern Body</em>'. | ||
| 271 | * <!-- begin-user-doc --> | 226 | * <!-- begin-user-doc --> |
| 272 | * <!-- end-user-doc --> | 227 | * <!-- end-user-doc --> |
| 273 | * @return a new object of class '<em>Pattern Body</em>'. | 228 | * @return a new object of class '<em>Literal</em>'. |
| 274 | * @generated | 229 | * @generated |
| 275 | */ | 230 | */ |
| 276 | PatternBody createPatternBody(); | 231 | Literal createLiteral(); |
| 277 | 232 | ||
| 278 | /** | 233 | /** |
| 279 | * Returns a new object of class '<em>Polarity</em>'. | 234 | * Returns a new object of class '<em>Logic Literal</em>'. |
| 280 | * <!-- begin-user-doc --> | 235 | * <!-- begin-user-doc --> |
| 281 | * <!-- end-user-doc --> | 236 | * <!-- end-user-doc --> |
| 282 | * @return a new object of class '<em>Polarity</em>'. | 237 | * @return a new object of class '<em>Logic Literal</em>'. |
| 283 | * @generated | 238 | * @generated |
| 284 | */ | 239 | */ |
| 285 | Polarity createPolarity(); | 240 | LogicLiteral createLogicLiteral(); |
| 286 | 241 | ||
| 287 | /** | 242 | /** |
| 288 | * Returns a new object of class '<em>Constraint</em>'. | 243 | * Returns a new object of class '<em>Numeric Literal</em>'. |
| 289 | * <!-- begin-user-doc --> | 244 | * <!-- begin-user-doc --> |
| 290 | * <!-- end-user-doc --> | 245 | * <!-- end-user-doc --> |
| 291 | * @return a new object of class '<em>Constraint</em>'. | 246 | * @return a new object of class '<em>Numeric Literal</em>'. |
| 292 | * @generated | 247 | * @generated |
| 293 | */ | 248 | */ |
| 294 | Constraint createConstraint(); | 249 | NumericLiteral createNumericLiteral(); |
| 295 | 250 | ||
| 296 | /** | 251 | /** |
| 297 | * Returns a new object of class '<em>Closure Type</em>'. | 252 | * Returns a new object of class '<em>Infinity Literal</em>'. |
| 298 | * <!-- begin-user-doc --> | 253 | * <!-- begin-user-doc --> |
| 299 | * <!-- end-user-doc --> | 254 | * <!-- end-user-doc --> |
| 300 | * @return a new object of class '<em>Closure Type</em>'. | 255 | * @return a new object of class '<em>Infinity Literal</em>'. |
| 301 | * @generated | 256 | * @generated |
| 302 | */ | 257 | */ |
| 303 | ClosureType createClosureType(); | 258 | InfinityLiteral createInfinityLiteral(); |
| 304 | 259 | ||
| 305 | /** | 260 | /** |
| 306 | * Returns a new object of class '<em>Literal</em>'. | 261 | * Returns a new object of class '<em>Empty Interval Literal</em>'. |
| 307 | * <!-- begin-user-doc --> | 262 | * <!-- begin-user-doc --> |
| 308 | * <!-- end-user-doc --> | 263 | * <!-- end-user-doc --> |
| 309 | * @return a new object of class '<em>Literal</em>'. | 264 | * @return a new object of class '<em>Empty Interval Literal</em>'. |
| 310 | * @generated | 265 | * @generated |
| 311 | */ | 266 | */ |
| 312 | Literal createLiteral(); | 267 | EmptyIntervalLiteral createEmptyIntervalLiteral(); |
| 313 | 268 | ||
| 314 | /** | 269 | /** |
| 315 | * Returns a new object of class '<em>Variable</em>'. | 270 | * Returns a new object of class '<em>String Literal</em>'. |
| 316 | * <!-- begin-user-doc --> | 271 | * <!-- begin-user-doc --> |
| 317 | * <!-- end-user-doc --> | 272 | * <!-- end-user-doc --> |
| 318 | * @return a new object of class '<em>Variable</em>'. | 273 | * @return a new object of class '<em>String Literal</em>'. |
| 319 | * @generated | 274 | * @generated |
| 320 | */ | 275 | */ |
| 321 | Variable createVariable(); | 276 | StringLiteral createStringLiteral(); |
| 322 | 277 | ||
| 323 | /** | 278 | /** |
| 324 | * Returns a new object of class '<em>All Instances</em>'. | 279 | * Returns a new object of class '<em>Class Definition</em>'. |
| 325 | * <!-- begin-user-doc --> | 280 | * <!-- begin-user-doc --> |
| 326 | * <!-- end-user-doc --> | 281 | * <!-- end-user-doc --> |
| 327 | * @return a new object of class '<em>All Instances</em>'. | 282 | * @return a new object of class '<em>Class Definition</em>'. |
| 328 | * @generated | 283 | * @generated |
| 329 | */ | 284 | */ |
| 330 | AllInstances createAllInstances(); | 285 | ClassDefinition createClassDefinition(); |
| 331 | 286 | ||
| 332 | /** | 287 | /** |
| 333 | * Returns a new object of class '<em>All Objects</em>'. | 288 | * Returns a new object of class '<em>Member Definition</em>'. |
| 334 | * <!-- begin-user-doc --> | 289 | * <!-- begin-user-doc --> |
| 335 | * <!-- end-user-doc --> | 290 | * <!-- end-user-doc --> |
| 336 | * @return a new object of class '<em>All Objects</em>'. | 291 | * @return a new object of class '<em>Member Definition</em>'. |
| 337 | * @generated | 292 | * @generated |
| 338 | */ | 293 | */ |
| 339 | AllObjects createAllObjects(); | 294 | MemberDefinition createMemberDefinition(); |
| 340 | 295 | ||
| 341 | /** | 296 | /** |
| 342 | * Returns a new object of class '<em>Default Interpretation</em>'. | 297 | * Returns a new object of class '<em>Multiplicity</em>'. |
| 343 | * <!-- begin-user-doc --> | 298 | * <!-- begin-user-doc --> |
| 344 | * <!-- end-user-doc --> | 299 | * <!-- end-user-doc --> |
| 345 | * @return a new object of class '<em>Default Interpretation</em>'. | 300 | * @return a new object of class '<em>Multiplicity</em>'. |
| 346 | * @generated | 301 | * @generated |
| 347 | */ | 302 | */ |
| 348 | DefaultInterpretation createDefaultInterpretation(); | 303 | Multiplicity createMultiplicity(); |
| 349 | 304 | ||
| 350 | /** | 305 | /** |
| 351 | * Returns a new object of class '<em>CD Interpretation</em>'. | 306 | * Returns a new object of class '<em>Many Multiplicity</em>'. |
| 352 | * <!-- begin-user-doc --> | 307 | * <!-- begin-user-doc --> |
| 353 | * <!-- end-user-doc --> | 308 | * <!-- end-user-doc --> |
| 354 | * @return a new object of class '<em>CD Interpretation</em>'. | 309 | * @return a new object of class '<em>Many Multiplicity</em>'. |
| 355 | * @generated | 310 | * @generated |
| 356 | */ | 311 | */ |
| 357 | CDInterpretation createCDInterpretation(); | 312 | ManyMultiplicity createManyMultiplicity(); |
| 358 | 313 | ||
| 359 | /** | 314 | /** |
| 360 | * Returns a new object of class '<em>Class Interpretation</em>'. | 315 | * Returns a new object of class '<em>Exact Multiplicity</em>'. |
| 361 | * <!-- begin-user-doc --> | 316 | * <!-- begin-user-doc --> |
| 362 | * <!-- end-user-doc --> | 317 | * <!-- end-user-doc --> |
| 363 | * @return a new object of class '<em>Class Interpretation</em>'. | 318 | * @return a new object of class '<em>Exact Multiplicity</em>'. |
| 364 | * @generated | 319 | * @generated |
| 365 | */ | 320 | */ |
| 366 | ClassInterpretation createClassInterpretation(); | 321 | ExactMultiplicity createExactMultiplicity(); |
| 367 | 322 | ||
| 368 | /** | 323 | /** |
| 369 | * Returns a new object of class '<em>Enum Interpretation</em>'. | 324 | * Returns a new object of class '<em>Bounded Multiplicity</em>'. |
| 370 | * <!-- begin-user-doc --> | 325 | * <!-- begin-user-doc --> |
| 371 | * <!-- end-user-doc --> | 326 | * <!-- end-user-doc --> |
| 372 | * @return a new object of class '<em>Enum Interpretation</em>'. | 327 | * @return a new object of class '<em>Bounded Multiplicity</em>'. |
| 373 | * @generated | 328 | * @generated |
| 374 | */ | 329 | */ |
| 375 | EnumInterpretation createEnumInterpretation(); | 330 | BoundedMultiplicity createBoundedMultiplicity(); |
| 376 | 331 | ||
| 377 | /** | 332 | /** |
| 378 | * Returns a new object of class '<em>Field Relation Interpretation</em>'. | 333 | * Returns a new object of class '<em>Scope Definition</em>'. |
| 379 | * <!-- begin-user-doc --> | 334 | * <!-- begin-user-doc --> |
| 380 | * <!-- end-user-doc --> | 335 | * <!-- end-user-doc --> |
| 381 | * @return a new object of class '<em>Field Relation Interpretation</em>'. | 336 | * @return a new object of class '<em>Scope Definition</em>'. |
| 382 | * @generated | 337 | * @generated |
| 383 | */ | 338 | */ |
| 384 | FieldRelationInterpretation createFieldRelationInterpretation(); | 339 | ScopeDefinition createScopeDefinition(); |
| 385 | 340 | ||
| 386 | /** | 341 | /** |
| 387 | * Returns a new object of class '<em>Global Relation Interpretation</em>'. | 342 | * Returns a new object of class '<em>Exact Scope Definition</em>'. |
| 388 | * <!-- begin-user-doc --> | 343 | * <!-- begin-user-doc --> |
| 389 | * <!-- end-user-doc --> | 344 | * <!-- end-user-doc --> |
| 390 | * @return a new object of class '<em>Global Relation Interpretation</em>'. | 345 | * @return a new object of class '<em>Exact Scope Definition</em>'. |
| 391 | * @generated | 346 | * @generated |
| 392 | */ | 347 | */ |
| 393 | GlobalRelationInterpretation createGlobalRelationInterpretation(); | 348 | ExactScopeDefinition createExactScopeDefinition(); |
| 394 | 349 | ||
| 395 | /** | 350 | /** |
| 396 | * Returns a new object of class '<em>Multiplicity Definition</em>'. | 351 | * Returns a new object of class '<em>Bounded Scope Definition</em>'. |
| 397 | * <!-- begin-user-doc --> | 352 | * <!-- begin-user-doc --> |
| 398 | * <!-- end-user-doc --> | 353 | * <!-- end-user-doc --> |
| 399 | * @return a new object of class '<em>Multiplicity Definition</em>'. | 354 | * @return a new object of class '<em>Bounded Scope Definition</em>'. |
| 400 | * @generated | 355 | * @generated |
| 401 | */ | 356 | */ |
| 402 | MultiplicityDefinition createMultiplicityDefinition(); | 357 | BoundedScopeDefinition createBoundedScopeDefinition(); |
| 403 | 358 | ||
| 404 | /** | 359 | /** |
| 405 | * Returns a new object of class '<em>Boolean True</em>'. | 360 | * Returns a new object of class '<em>Lower Bounded Scope Definition</em>'. |
| 406 | * <!-- begin-user-doc --> | 361 | * <!-- begin-user-doc --> |
| 407 | * <!-- end-user-doc --> | 362 | * <!-- end-user-doc --> |
| 408 | * @return a new object of class '<em>Boolean True</em>'. | 363 | * @return a new object of class '<em>Lower Bounded Scope Definition</em>'. |
| 409 | * @generated | 364 | * @generated |
| 410 | */ | 365 | */ |
| 411 | BooleanTrue createBooleanTrue(); | 366 | LowerBoundedScopeDefinition createLowerBoundedScopeDefinition(); |
| 412 | 367 | ||
| 413 | /** | 368 | /** |
| 414 | * Returns a new object of class '<em>Boolean False</em>'. | 369 | * Returns a new object of class '<em>Objective Definition</em>'. |
| 415 | * <!-- begin-user-doc --> | 370 | * <!-- begin-user-doc --> |
| 416 | * <!-- end-user-doc --> | 371 | * <!-- end-user-doc --> |
| 417 | * @return a new object of class '<em>Boolean False</em>'. | 372 | * @return a new object of class '<em>Objective Definition</em>'. |
| 418 | * @generated | 373 | * @generated |
| 419 | */ | 374 | */ |
| 420 | BooleanFalse createBooleanFalse(); | 375 | ObjectiveDefinition createObjectiveDefinition(); |
| 421 | 376 | ||
| 422 | /** | 377 | /** |
| 423 | * Returns a new object of class '<em>True</em>'. | 378 | * Returns a new object of class '<em>Named Element</em>'. |
| 424 | * <!-- begin-user-doc --> | 379 | * <!-- begin-user-doc --> |
| 425 | * <!-- end-user-doc --> | 380 | * <!-- end-user-doc --> |
| 426 | * @return a new object of class '<em>True</em>'. | 381 | * @return a new object of class '<em>Named Element</em>'. |
| 427 | * @generated | 382 | * @generated |
| 428 | */ | 383 | */ |
| 429 | True createTrue(); | 384 | NamedElement createNamedElement(); |
| 430 | 385 | ||
| 431 | /** | 386 | /** |
| 432 | * Returns a new object of class '<em>False</em>'. | 387 | * Returns a new object of class '<em>Assertion</em>'. |
| 433 | * <!-- begin-user-doc --> | 388 | * <!-- begin-user-doc --> |
| 434 | * <!-- end-user-doc --> | 389 | * <!-- end-user-doc --> |
| 435 | * @return a new object of class '<em>False</em>'. | 390 | * @return a new object of class '<em>Assertion</em>'. |
| 436 | * @generated | 391 | * @generated |
| 437 | */ | 392 | */ |
| 438 | False createFalse(); | 393 | Assertion createAssertion(); |
| 439 | 394 | ||
| 440 | /** | 395 | /** |
| 441 | * Returns a new object of class '<em>Unknown</em>'. | 396 | * Returns a new object of class '<em>Disjunction</em>'. |
| 442 | * <!-- begin-user-doc --> | 397 | * <!-- begin-user-doc --> |
| 443 | * <!-- end-user-doc --> | 398 | * <!-- end-user-doc --> |
| 444 | * @return a new object of class '<em>Unknown</em>'. | 399 | * @return a new object of class '<em>Disjunction</em>'. |
| 445 | * @generated | 400 | * @generated |
| 446 | */ | 401 | */ |
| 447 | Unknown createUnknown(); | 402 | Disjunction createDisjunction(); |
| 448 | 403 | ||
| 449 | /** | 404 | /** |
| 450 | * Returns a new object of class '<em>Error</em>'. | 405 | * Returns a new object of class '<em>Switch</em>'. |
| 451 | * <!-- begin-user-doc --> | 406 | * <!-- begin-user-doc --> |
| 452 | * <!-- end-user-doc --> | 407 | * <!-- end-user-doc --> |
| 453 | * @return a new object of class '<em>Error</em>'. | 408 | * @return a new object of class '<em>Switch</em>'. |
| 454 | * @generated | 409 | * @generated |
| 455 | */ | 410 | */ |
| 456 | Error createError(); | 411 | Switch createSwitch(); |
| 457 | 412 | ||
| 458 | /** | 413 | /** |
| 459 | * Returns a new object of class '<em>Positive</em>'. | 414 | * Returns a new object of class '<em>Conjunction</em>'. |
| 460 | * <!-- begin-user-doc --> | 415 | * <!-- begin-user-doc --> |
| 461 | * <!-- end-user-doc --> | 416 | * <!-- end-user-doc --> |
| 462 | * @return a new object of class '<em>Positive</em>'. | 417 | * @return a new object of class '<em>Conjunction</em>'. |
| 463 | * @generated | 418 | * @generated |
| 464 | */ | 419 | */ |
| 465 | Positive createPositive(); | 420 | Conjunction createConjunction(); |
| 466 | 421 | ||
| 467 | /** | 422 | /** |
| 468 | * Returns a new object of class '<em>Negative</em>'. | 423 | * Returns a new object of class '<em>Comparison</em>'. |
| 469 | * <!-- begin-user-doc --> | 424 | * <!-- begin-user-doc --> |
| 470 | * <!-- end-user-doc --> | 425 | * <!-- end-user-doc --> |
| 471 | * @return a new object of class '<em>Negative</em>'. | 426 | * @return a new object of class '<em>Comparison</em>'. |
| 472 | * @generated | 427 | * @generated |
| 473 | */ | 428 | */ |
| 474 | Negative createNegative(); | 429 | Comparison createComparison(); |
| 475 | 430 | ||
| 476 | /** | 431 | /** |
| 477 | * Returns a new object of class '<em>Reflexive Closure</em>'. | 432 | * Returns a new object of class '<em>Binary Expression</em>'. |
| 478 | * <!-- begin-user-doc --> | 433 | * <!-- begin-user-doc --> |
| 479 | * <!-- end-user-doc --> | 434 | * <!-- end-user-doc --> |
| 480 | * @return a new object of class '<em>Reflexive Closure</em>'. | 435 | * @return a new object of class '<em>Binary Expression</em>'. |
| 481 | * @generated | 436 | * @generated |
| 482 | */ | 437 | */ |
| 483 | ReflexiveClosure createReflexiveClosure(); | 438 | BinaryExpression createBinaryExpression(); |
| 484 | 439 | ||
| 485 | /** | 440 | /** |
| 486 | * Returns a new object of class '<em>Irreflexive Closure</em>'. | 441 | * Returns a new object of class '<em>Unary Expression</em>'. |
| 487 | * <!-- begin-user-doc --> | 442 | * <!-- begin-user-doc --> |
| 488 | * <!-- end-user-doc --> | 443 | * <!-- end-user-doc --> |
| 489 | * @return a new object of class '<em>Irreflexive Closure</em>'. | 444 | * @return a new object of class '<em>Unary Expression</em>'. |
| 490 | * @generated | 445 | * @generated |
| 491 | */ | 446 | */ |
| 492 | IrreflexiveClosure createIrreflexiveClosure(); | 447 | UnaryExpression createUnaryExpression(); |
| 493 | 448 | ||
| 494 | /** | 449 | /** |
| 495 | * Returns the package supported by this factory. | 450 | * Returns the package supported by this factory. |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java index 9767d002..ac9279c3 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java | |||
| @@ -1,10 +1,11 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EAttribute; | 6 | import org.eclipse.emf.ecore.EAttribute; |
| 7 | import org.eclipse.emf.ecore.EClass; | 7 | import org.eclipse.emf.ecore.EClass; |
| 8 | import org.eclipse.emf.ecore.EEnum; | ||
| 8 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
| 9 | import org.eclipse.emf.ecore.EReference; | 10 | import org.eclipse.emf.ecore.EReference; |
| 10 | 11 | ||
| @@ -105,1341 +106,1585 @@ public interface SolverLanguagePackage extends EPackage | |||
| 105 | int STATEMENT_FEATURE_COUNT = 0; | 106 | int STATEMENT_FEATURE_COUNT = 0; |
| 106 | 107 | ||
| 107 | /** | 108 | /** |
| 108 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl <em>Boolean Value</em>}' class. | 109 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl <em>Predicate Definition</em>}' class. |
| 109 | * <!-- begin-user-doc --> | 110 | * <!-- begin-user-doc --> |
| 110 | * <!-- end-user-doc --> | 111 | * <!-- end-user-doc --> |
| 111 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl | 112 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl |
| 112 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue() | 113 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateDefinition() |
| 113 | * @generated | 114 | * @generated |
| 114 | */ | 115 | */ |
| 115 | int BOOLEAN_VALUE = 2; | 116 | int PREDICATE_DEFINITION = 2; |
| 116 | 117 | ||
| 117 | /** | 118 | /** |
| 118 | * The number of structural features of the '<em>Boolean Value</em>' class. | 119 | * The feature id for the '<em><b>Head</b></em>' containment reference. |
| 119 | * <!-- begin-user-doc --> | 120 | * <!-- begin-user-doc --> |
| 120 | * <!-- end-user-doc --> | 121 | * <!-- end-user-doc --> |
| 121 | * @generated | 122 | * @generated |
| 122 | * @ordered | 123 | * @ordered |
| 123 | */ | 124 | */ |
| 124 | int BOOLEAN_VALUE_FEATURE_COUNT = 0; | 125 | int PREDICATE_DEFINITION__HEAD = STATEMENT_FEATURE_COUNT + 0; |
| 125 | 126 | ||
| 126 | /** | 127 | /** |
| 127 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl <em>Truth Value</em>}' class. | 128 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 128 | * <!-- begin-user-doc --> | 129 | * <!-- begin-user-doc --> |
| 129 | * <!-- end-user-doc --> | 130 | * <!-- end-user-doc --> |
| 130 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl | ||
| 131 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue() | ||
| 132 | * @generated | 131 | * @generated |
| 132 | * @ordered | ||
| 133 | */ | 133 | */ |
| 134 | int TRUTH_VALUE = 3; | 134 | int PREDICATE_DEFINITION__BODY = STATEMENT_FEATURE_COUNT + 1; |
| 135 | 135 | ||
| 136 | /** | 136 | /** |
| 137 | * The number of structural features of the '<em>Truth Value</em>' class. | 137 | * The feature id for the '<em><b>Functional</b></em>' attribute. |
| 138 | * <!-- begin-user-doc --> | 138 | * <!-- begin-user-doc --> |
| 139 | * <!-- end-user-doc --> | 139 | * <!-- end-user-doc --> |
| 140 | * @generated | 140 | * @generated |
| 141 | * @ordered | 141 | * @ordered |
| 142 | */ | 142 | */ |
| 143 | int TRUTH_VALUE_FEATURE_COUNT = 0; | 143 | int PREDICATE_DEFINITION__FUNCTIONAL = STATEMENT_FEATURE_COUNT + 2; |
| 144 | 144 | ||
| 145 | /** | 145 | /** |
| 146 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl <em>Interpretation</em>}' class. | 146 | * The feature id for the '<em><b>Error</b></em>' attribute. |
| 147 | * <!-- begin-user-doc --> | 147 | * <!-- begin-user-doc --> |
| 148 | * <!-- end-user-doc --> | 148 | * <!-- end-user-doc --> |
| 149 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl | ||
| 150 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation() | ||
| 151 | * @generated | 149 | * @generated |
| 150 | * @ordered | ||
| 152 | */ | 151 | */ |
| 153 | int INTERPRETATION = 4; | 152 | int PREDICATE_DEFINITION__ERROR = STATEMENT_FEATURE_COUNT + 3; |
| 154 | 153 | ||
| 155 | /** | 154 | /** |
| 156 | * The number of structural features of the '<em>Interpretation</em>' class. | 155 | * The number of structural features of the '<em>Predicate Definition</em>' class. |
| 157 | * <!-- begin-user-doc --> | 156 | * <!-- begin-user-doc --> |
| 158 | * <!-- end-user-doc --> | 157 | * <!-- end-user-doc --> |
| 159 | * @generated | 158 | * @generated |
| 160 | * @ordered | 159 | * @ordered |
| 161 | */ | 160 | */ |
| 162 | int INTERPRETATION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 0; | 161 | int PREDICATE_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 4; |
| 163 | 162 | ||
| 164 | /** | 163 | /** |
| 165 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl <em>Basic Interpretation</em>}' class. | 164 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl <em>Unnamed Error Prediate Definition</em>}' class. |
| 166 | * <!-- begin-user-doc --> | 165 | * <!-- begin-user-doc --> |
| 167 | * <!-- end-user-doc --> | 166 | * <!-- end-user-doc --> |
| 168 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl | 167 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl |
| 169 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation() | 168 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedErrorPrediateDefinition() |
| 170 | * @generated | 169 | * @generated |
| 171 | */ | 170 | */ |
| 172 | int BASIC_INTERPRETATION = 5; | 171 | int UNNAMED_ERROR_PREDIATE_DEFINITION = 3; |
| 173 | 172 | ||
| 174 | /** | 173 | /** |
| 175 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 174 | * The feature id for the '<em><b>Argument List</b></em>' containment reference. |
| 176 | * <!-- begin-user-doc --> | 175 | * <!-- begin-user-doc --> |
| 177 | * <!-- end-user-doc --> | 176 | * <!-- end-user-doc --> |
| 178 | * @generated | 177 | * @generated |
| 179 | * @ordered | 178 | * @ordered |
| 180 | */ | 179 | */ |
| 181 | int BASIC_INTERPRETATION__SYMBOL = INTERPRETATION_FEATURE_COUNT + 0; | 180 | int UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST = STATEMENT_FEATURE_COUNT + 0; |
| 182 | 181 | ||
| 183 | /** | 182 | /** |
| 184 | * The feature id for the '<em><b>Objects</b></em>' containment reference list. | 183 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 185 | * <!-- begin-user-doc --> | 184 | * <!-- begin-user-doc --> |
| 186 | * <!-- end-user-doc --> | 185 | * <!-- end-user-doc --> |
| 187 | * @generated | 186 | * @generated |
| 188 | * @ordered | 187 | * @ordered |
| 189 | */ | 188 | */ |
| 190 | int BASIC_INTERPRETATION__OBJECTS = INTERPRETATION_FEATURE_COUNT + 1; | 189 | int UNNAMED_ERROR_PREDIATE_DEFINITION__BODY = STATEMENT_FEATURE_COUNT + 1; |
| 191 | 190 | ||
| 192 | /** | 191 | /** |
| 193 | * The feature id for the '<em><b>Value</b></em>' containment reference. | 192 | * The number of structural features of the '<em>Unnamed Error Prediate Definition</em>' class. |
| 194 | * <!-- begin-user-doc --> | 193 | * <!-- begin-user-doc --> |
| 195 | * <!-- end-user-doc --> | 194 | * <!-- end-user-doc --> |
| 196 | * @generated | 195 | * @generated |
| 197 | * @ordered | 196 | * @ordered |
| 198 | */ | 197 | */ |
| 199 | int BASIC_INTERPRETATION__VALUE = INTERPRETATION_FEATURE_COUNT + 2; | 198 | int UNNAMED_ERROR_PREDIATE_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; |
| 199 | |||
| 200 | /** | ||
| 201 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl <em>Default Definition</em>}' class. | ||
| 202 | * <!-- begin-user-doc --> | ||
| 203 | * <!-- end-user-doc --> | ||
| 204 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl | ||
| 205 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultDefinition() | ||
| 206 | * @generated | ||
| 207 | */ | ||
| 208 | int DEFAULT_DEFINITION = 4; | ||
| 200 | 209 | ||
| 201 | /** | 210 | /** |
| 202 | * The number of structural features of the '<em>Basic Interpretation</em>' class. | 211 | * The feature id for the '<em><b>Head</b></em>' containment reference. |
| 203 | * <!-- begin-user-doc --> | 212 | * <!-- begin-user-doc --> |
| 204 | * <!-- end-user-doc --> | 213 | * <!-- end-user-doc --> |
| 205 | * @generated | 214 | * @generated |
| 206 | * @ordered | 215 | * @ordered |
| 207 | */ | 216 | */ |
| 208 | int BASIC_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 3; | 217 | int DEFAULT_DEFINITION__HEAD = STATEMENT_FEATURE_COUNT + 0; |
| 209 | 218 | ||
| 210 | /** | 219 | /** |
| 211 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl <em>Symbol</em>}' class. | 220 | * The feature id for the '<em><b>Range</b></em>' containment reference. |
| 212 | * <!-- begin-user-doc --> | 221 | * <!-- begin-user-doc --> |
| 213 | * <!-- end-user-doc --> | 222 | * <!-- end-user-doc --> |
| 214 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl | ||
| 215 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol() | ||
| 216 | * @generated | 223 | * @generated |
| 224 | * @ordered | ||
| 217 | */ | 225 | */ |
| 218 | int SYMBOL = 6; | 226 | int DEFAULT_DEFINITION__RANGE = STATEMENT_FEATURE_COUNT + 1; |
| 219 | 227 | ||
| 220 | /** | 228 | /** |
| 221 | * The number of structural features of the '<em>Symbol</em>' class. | 229 | * The number of structural features of the '<em>Default Definition</em>' class. |
| 222 | * <!-- begin-user-doc --> | 230 | * <!-- begin-user-doc --> |
| 223 | * <!-- end-user-doc --> | 231 | * <!-- end-user-doc --> |
| 224 | * @generated | 232 | * @generated |
| 225 | * @ordered | 233 | * @ordered |
| 226 | */ | 234 | */ |
| 227 | int SYMBOL_FEATURE_COUNT = 0; | 235 | int DEFAULT_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; |
| 228 | 236 | ||
| 229 | /** | 237 | /** |
| 230 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl <em>Model Symbol</em>}' class. | 238 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternPredicateDefinitionImpl <em>Extern Predicate Definition</em>}' class. |
| 231 | * <!-- begin-user-doc --> | 239 | * <!-- begin-user-doc --> |
| 232 | * <!-- end-user-doc --> | 240 | * <!-- end-user-doc --> |
| 233 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl | 241 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExternPredicateDefinitionImpl |
| 234 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol() | 242 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExternPredicateDefinition() |
| 235 | * @generated | 243 | * @generated |
| 236 | */ | 244 | */ |
| 237 | int MODEL_SYMBOL = 7; | 245 | int EXTERN_PREDICATE_DEFINITION = 5; |
| 238 | 246 | ||
| 239 | /** | 247 | /** |
| 240 | * The feature id for the '<em><b>Name</b></em>' attribute. | 248 | * The feature id for the '<em><b>Head</b></em>' containment reference. |
| 241 | * <!-- begin-user-doc --> | 249 | * <!-- begin-user-doc --> |
| 242 | * <!-- end-user-doc --> | 250 | * <!-- end-user-doc --> |
| 243 | * @generated | 251 | * @generated |
| 244 | * @ordered | 252 | * @ordered |
| 245 | */ | 253 | */ |
| 246 | int MODEL_SYMBOL__NAME = SYMBOL_FEATURE_COUNT + 0; | 254 | int EXTERN_PREDICATE_DEFINITION__HEAD = STATEMENT_FEATURE_COUNT + 0; |
| 247 | 255 | ||
| 248 | /** | 256 | /** |
| 249 | * The number of structural features of the '<em>Model Symbol</em>' class. | 257 | * The number of structural features of the '<em>Extern Predicate Definition</em>' class. |
| 250 | * <!-- begin-user-doc --> | 258 | * <!-- begin-user-doc --> |
| 251 | * <!-- end-user-doc --> | 259 | * <!-- end-user-doc --> |
| 252 | * @generated | 260 | * @generated |
| 253 | * @ordered | 261 | * @ordered |
| 254 | */ | 262 | */ |
| 255 | int MODEL_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 1; | 263 | int EXTERN_PREDICATE_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 1; |
| 256 | 264 | ||
| 257 | /** | 265 | /** |
| 258 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl <em>Partiality Symbol</em>}' class. | 266 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl <em>Metric Definition</em>}' class. |
| 259 | * <!-- begin-user-doc --> | 267 | * <!-- begin-user-doc --> |
| 260 | * <!-- end-user-doc --> | 268 | * <!-- end-user-doc --> |
| 261 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl | 269 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl |
| 262 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol() | 270 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMetricDefinition() |
| 263 | * @generated | 271 | * @generated |
| 264 | */ | 272 | */ |
| 265 | int PARTIALITY_SYMBOL = 8; | 273 | int METRIC_DEFINITION = 6; |
| 266 | 274 | ||
| 267 | /** | 275 | /** |
| 268 | * The number of structural features of the '<em>Partiality Symbol</em>' class. | 276 | * The feature id for the '<em><b>Head</b></em>' containment reference. |
| 269 | * <!-- begin-user-doc --> | 277 | * <!-- begin-user-doc --> |
| 270 | * <!-- end-user-doc --> | 278 | * <!-- end-user-doc --> |
| 271 | * @generated | 279 | * @generated |
| 272 | * @ordered | 280 | * @ordered |
| 273 | */ | 281 | */ |
| 274 | int PARTIALITY_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0; | 282 | int METRIC_DEFINITION__HEAD = STATEMENT_FEATURE_COUNT + 0; |
| 275 | 283 | ||
| 276 | /** | 284 | /** |
| 277 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl <em>Exist Symbol</em>}' class. | 285 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 278 | * <!-- begin-user-doc --> | 286 | * <!-- begin-user-doc --> |
| 279 | * <!-- end-user-doc --> | 287 | * <!-- end-user-doc --> |
| 280 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl | ||
| 281 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol() | ||
| 282 | * @generated | 288 | * @generated |
| 289 | * @ordered | ||
| 283 | */ | 290 | */ |
| 284 | int EXIST_SYMBOL = 9; | 291 | int METRIC_DEFINITION__BODY = STATEMENT_FEATURE_COUNT + 1; |
| 285 | 292 | ||
| 286 | /** | 293 | /** |
| 287 | * The number of structural features of the '<em>Exist Symbol</em>' class. | 294 | * The feature id for the '<em><b>Type</b></em>' attribute. |
| 288 | * <!-- begin-user-doc --> | 295 | * <!-- begin-user-doc --> |
| 289 | * <!-- end-user-doc --> | 296 | * <!-- end-user-doc --> |
| 290 | * @generated | 297 | * @generated |
| 291 | * @ordered | 298 | * @ordered |
| 292 | */ | 299 | */ |
| 293 | int EXIST_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0; | 300 | int METRIC_DEFINITION__TYPE = STATEMENT_FEATURE_COUNT + 2; |
| 294 | 301 | ||
| 295 | /** | 302 | /** |
| 296 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl <em>Equals Symbol</em>}' class. | 303 | * The number of structural features of the '<em>Metric Definition</em>' class. |
| 297 | * <!-- begin-user-doc --> | 304 | * <!-- begin-user-doc --> |
| 298 | * <!-- end-user-doc --> | 305 | * <!-- end-user-doc --> |
| 299 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl | ||
| 300 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol() | ||
| 301 | * @generated | 306 | * @generated |
| 307 | * @ordered | ||
| 302 | */ | 308 | */ |
| 303 | int EQUALS_SYMBOL = 10; | 309 | int METRIC_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 3; |
| 304 | 310 | ||
| 305 | /** | 311 | /** |
| 306 | * The number of structural features of the '<em>Equals Symbol</em>' class. | 312 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl <em>Extern Metric Definition</em>}' class. |
| 313 | * <!-- begin-user-doc --> | ||
| 314 | * <!-- end-user-doc --> | ||
| 315 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl | ||
| 316 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExternMetricDefinition() | ||
| 317 | * @generated | ||
| 318 | */ | ||
| 319 | int EXTERN_METRIC_DEFINITION = 7; | ||
| 320 | |||
| 321 | /** | ||
| 322 | * The feature id for the '<em><b>Type</b></em>' attribute. | ||
| 307 | * <!-- begin-user-doc --> | 323 | * <!-- begin-user-doc --> |
| 308 | * <!-- end-user-doc --> | 324 | * <!-- end-user-doc --> |
| 309 | * @generated | 325 | * @generated |
| 310 | * @ordered | 326 | * @ordered |
| 311 | */ | 327 | */ |
| 312 | int EQUALS_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0; | 328 | int EXTERN_METRIC_DEFINITION__TYPE = STATEMENT_FEATURE_COUNT + 0; |
| 313 | 329 | ||
| 314 | /** | 330 | /** |
| 315 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl <em>Data Symbol</em>}' class. | 331 | * The feature id for the '<em><b>Head</b></em>' containment reference. |
| 316 | * <!-- begin-user-doc --> | 332 | * <!-- begin-user-doc --> |
| 317 | * <!-- end-user-doc --> | 333 | * <!-- end-user-doc --> |
| 318 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl | ||
| 319 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol() | ||
| 320 | * @generated | 334 | * @generated |
| 335 | * @ordered | ||
| 321 | */ | 336 | */ |
| 322 | int DATA_SYMBOL = 11; | 337 | int EXTERN_METRIC_DEFINITION__HEAD = STATEMENT_FEATURE_COUNT + 1; |
| 323 | 338 | ||
| 324 | /** | 339 | /** |
| 325 | * The number of structural features of the '<em>Data Symbol</em>' class. | 340 | * The number of structural features of the '<em>Extern Metric Definition</em>' class. |
| 326 | * <!-- begin-user-doc --> | 341 | * <!-- begin-user-doc --> |
| 327 | * <!-- end-user-doc --> | 342 | * <!-- end-user-doc --> |
| 328 | * @generated | 343 | * @generated |
| 329 | * @ordered | 344 | * @ordered |
| 330 | */ | 345 | */ |
| 331 | int DATA_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0; | 346 | int EXTERN_METRIC_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; |
| 332 | 347 | ||
| 333 | /** | 348 | /** |
| 334 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl <em>Boolean Symbol</em>}' class. | 349 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionImpl <em>Expression</em>}' class. |
| 335 | * <!-- begin-user-doc --> | 350 | * <!-- begin-user-doc --> |
| 336 | * <!-- end-user-doc --> | 351 | * <!-- end-user-doc --> |
| 337 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl | 352 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionImpl |
| 338 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol() | 353 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExpression() |
| 339 | * @generated | 354 | * @generated |
| 340 | */ | 355 | */ |
| 341 | int BOOLEAN_SYMBOL = 12; | 356 | int EXPRESSION = 8; |
| 342 | 357 | ||
| 343 | /** | 358 | /** |
| 344 | * The number of structural features of the '<em>Boolean Symbol</em>' class. | 359 | * The number of structural features of the '<em>Expression</em>' class. |
| 345 | * <!-- begin-user-doc --> | 360 | * <!-- begin-user-doc --> |
| 346 | * <!-- end-user-doc --> | 361 | * <!-- end-user-doc --> |
| 347 | * @generated | 362 | * @generated |
| 348 | * @ordered | 363 | * @ordered |
| 349 | */ | 364 | */ |
| 350 | int BOOLEAN_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; | 365 | int EXPRESSION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 0; |
| 351 | 366 | ||
| 352 | /** | 367 | /** |
| 353 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl <em>Integer Symbol</em>}' class. | 368 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl <em>If Else</em>}' class. |
| 354 | * <!-- begin-user-doc --> | 369 | * <!-- begin-user-doc --> |
| 355 | * <!-- end-user-doc --> | 370 | * <!-- end-user-doc --> |
| 356 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl | 371 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl |
| 357 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol() | 372 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIfElse() |
| 358 | * @generated | 373 | * @generated |
| 359 | */ | 374 | */ |
| 360 | int INTEGER_SYMBOL = 13; | 375 | int IF_ELSE = 9; |
| 361 | 376 | ||
| 362 | /** | 377 | /** |
| 363 | * The number of structural features of the '<em>Integer Symbol</em>' class. | 378 | * The feature id for the '<em><b>Condition</b></em>' containment reference. |
| 364 | * <!-- begin-user-doc --> | 379 | * <!-- begin-user-doc --> |
| 365 | * <!-- end-user-doc --> | 380 | * <!-- end-user-doc --> |
| 366 | * @generated | 381 | * @generated |
| 367 | * @ordered | 382 | * @ordered |
| 368 | */ | 383 | */ |
| 369 | int INTEGER_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; | 384 | int IF_ELSE__CONDITION = EXPRESSION_FEATURE_COUNT + 0; |
| 370 | 385 | ||
| 371 | /** | 386 | /** |
| 372 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl <em>Real Symbol</em>}' class. | 387 | * The feature id for the '<em><b>Then</b></em>' containment reference. |
| 373 | * <!-- begin-user-doc --> | 388 | * <!-- begin-user-doc --> |
| 374 | * <!-- end-user-doc --> | 389 | * <!-- end-user-doc --> |
| 375 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl | ||
| 376 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol() | ||
| 377 | * @generated | 390 | * @generated |
| 391 | * @ordered | ||
| 392 | */ | ||
| 393 | int IF_ELSE__THEN = EXPRESSION_FEATURE_COUNT + 1; | ||
| 394 | |||
| 395 | /** | ||
| 396 | * The feature id for the '<em><b>Else</b></em>' containment reference. | ||
| 397 | * <!-- begin-user-doc --> | ||
| 398 | * <!-- end-user-doc --> | ||
| 399 | * @generated | ||
| 400 | * @ordered | ||
| 378 | */ | 401 | */ |
| 379 | int REAL_SYMBOL = 14; | 402 | int IF_ELSE__ELSE = EXPRESSION_FEATURE_COUNT + 2; |
| 380 | 403 | ||
| 381 | /** | 404 | /** |
| 382 | * The number of structural features of the '<em>Real Symbol</em>' class. | 405 | * The number of structural features of the '<em>If Else</em>' class. |
| 383 | * <!-- begin-user-doc --> | 406 | * <!-- begin-user-doc --> |
| 384 | * <!-- end-user-doc --> | 407 | * <!-- end-user-doc --> |
| 385 | * @generated | 408 | * @generated |
| 386 | * @ordered | 409 | * @ordered |
| 387 | */ | 410 | */ |
| 388 | int REAL_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; | 411 | int IF_ELSE_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 3; |
| 389 | 412 | ||
| 390 | /** | 413 | /** |
| 391 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl <em>String Symbol</em>}' class. | 414 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl <em>Case</em>}' class. |
| 392 | * <!-- begin-user-doc --> | 415 | * <!-- begin-user-doc --> |
| 393 | * <!-- end-user-doc --> | 416 | * <!-- end-user-doc --> |
| 394 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl | 417 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl |
| 395 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol() | 418 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCase() |
| 396 | * @generated | 419 | * @generated |
| 397 | */ | 420 | */ |
| 398 | int STRING_SYMBOL = 15; | 421 | int CASE = 10; |
| 399 | 422 | ||
| 400 | /** | 423 | /** |
| 401 | * The number of structural features of the '<em>String Symbol</em>' class. | 424 | * The feature id for the '<em><b>Condition</b></em>' containment reference. |
| 402 | * <!-- begin-user-doc --> | 425 | * <!-- begin-user-doc --> |
| 403 | * <!-- end-user-doc --> | 426 | * <!-- end-user-doc --> |
| 404 | * @generated | 427 | * @generated |
| 405 | * @ordered | 428 | * @ordered |
| 406 | */ | 429 | */ |
| 407 | int STRING_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; | 430 | int CASE__CONDITION = EXPRESSION_FEATURE_COUNT + 0; |
| 408 | 431 | ||
| 409 | /** | 432 | /** |
| 410 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl <em>Complex Object</em>}' class. | 433 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 411 | * <!-- begin-user-doc --> | 434 | * <!-- begin-user-doc --> |
| 412 | * <!-- end-user-doc --> | 435 | * <!-- end-user-doc --> |
| 413 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl | ||
| 414 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject() | ||
| 415 | * @generated | 436 | * @generated |
| 437 | * @ordered | ||
| 416 | */ | 438 | */ |
| 417 | int COMPLEX_OBJECT = 16; | 439 | int CASE__BODY = EXPRESSION_FEATURE_COUNT + 1; |
| 418 | 440 | ||
| 419 | /** | 441 | /** |
| 420 | * The number of structural features of the '<em>Complex Object</em>' class. | 442 | * The number of structural features of the '<em>Case</em>' class. |
| 421 | * <!-- begin-user-doc --> | 443 | * <!-- begin-user-doc --> |
| 422 | * <!-- end-user-doc --> | 444 | * <!-- end-user-doc --> |
| 423 | * @generated | 445 | * @generated |
| 424 | * @ordered | 446 | * @ordered |
| 425 | */ | 447 | */ |
| 426 | int COMPLEX_OBJECT_FEATURE_COUNT = 0; | 448 | int CASE_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 2; |
| 427 | 449 | ||
| 428 | /** | 450 | /** |
| 429 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl <em>Object</em>}' class. | 451 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CountImpl <em>Count</em>}' class. |
| 430 | * <!-- begin-user-doc --> | 452 | * <!-- begin-user-doc --> |
| 431 | * <!-- end-user-doc --> | 453 | * <!-- end-user-doc --> |
| 432 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl | 454 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CountImpl |
| 433 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject() | 455 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCount() |
| 434 | * @generated | 456 | * @generated |
| 435 | */ | 457 | */ |
| 436 | int OBJECT = 17; | 458 | int COUNT = 11; |
| 437 | 459 | ||
| 438 | /** | 460 | /** |
| 439 | * The number of structural features of the '<em>Object</em>' class. | 461 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 440 | * <!-- begin-user-doc --> | 462 | * <!-- begin-user-doc --> |
| 441 | * <!-- end-user-doc --> | 463 | * <!-- end-user-doc --> |
| 442 | * @generated | 464 | * @generated |
| 443 | * @ordered | 465 | * @ordered |
| 444 | */ | 466 | */ |
| 445 | int OBJECT_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0; | 467 | int COUNT__BODY = EXPRESSION_FEATURE_COUNT + 0; |
| 446 | 468 | ||
| 447 | /** | 469 | /** |
| 448 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl <em>Named Object</em>}' class. | 470 | * The number of structural features of the '<em>Count</em>' class. |
| 449 | * <!-- begin-user-doc --> | 471 | * <!-- begin-user-doc --> |
| 450 | * <!-- end-user-doc --> | 472 | * <!-- end-user-doc --> |
| 451 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl | ||
| 452 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject() | ||
| 453 | * @generated | 473 | * @generated |
| 474 | * @ordered | ||
| 454 | */ | 475 | */ |
| 455 | int NAMED_OBJECT = 18; | 476 | int COUNT_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 1; |
| 456 | 477 | ||
| 457 | /** | 478 | /** |
| 458 | * The feature id for the '<em><b>Name</b></em>' attribute. | 479 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl <em>Aggregation</em>}' class. |
| 459 | * <!-- begin-user-doc --> | 480 | * <!-- begin-user-doc --> |
| 460 | * <!-- end-user-doc --> | 481 | * <!-- end-user-doc --> |
| 482 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl | ||
| 483 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAggregation() | ||
| 461 | * @generated | 484 | * @generated |
| 462 | * @ordered | ||
| 463 | */ | 485 | */ |
| 464 | int NAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0; | 486 | int AGGREGATION = 12; |
| 465 | 487 | ||
| 466 | /** | 488 | /** |
| 467 | * The number of structural features of the '<em>Named Object</em>' class. | 489 | * The feature id for the '<em><b>Op</b></em>' attribute. |
| 468 | * <!-- begin-user-doc --> | 490 | * <!-- begin-user-doc --> |
| 469 | * <!-- end-user-doc --> | 491 | * <!-- end-user-doc --> |
| 470 | * @generated | 492 | * @generated |
| 471 | * @ordered | 493 | * @ordered |
| 472 | */ | 494 | */ |
| 473 | int NAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1; | 495 | int AGGREGATION__OP = EXPRESSION_FEATURE_COUNT + 0; |
| 474 | 496 | ||
| 475 | /** | 497 | /** |
| 476 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl <em>Unnamed Object</em>}' class. | 498 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 477 | * <!-- begin-user-doc --> | 499 | * <!-- begin-user-doc --> |
| 478 | * <!-- end-user-doc --> | 500 | * <!-- end-user-doc --> |
| 479 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl | ||
| 480 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject() | ||
| 481 | * @generated | 501 | * @generated |
| 502 | * @ordered | ||
| 482 | */ | 503 | */ |
| 483 | int UNNAMED_OBJECT = 19; | 504 | int AGGREGATION__BODY = EXPRESSION_FEATURE_COUNT + 1; |
| 484 | 505 | ||
| 485 | /** | 506 | /** |
| 486 | * The feature id for the '<em><b>Name</b></em>' attribute. | 507 | * The feature id for the '<em><b>Condition</b></em>' containment reference. |
| 487 | * <!-- begin-user-doc --> | 508 | * <!-- begin-user-doc --> |
| 488 | * <!-- end-user-doc --> | 509 | * <!-- end-user-doc --> |
| 489 | * @generated | 510 | * @generated |
| 490 | * @ordered | 511 | * @ordered |
| 491 | */ | 512 | */ |
| 492 | int UNNAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0; | 513 | int AGGREGATION__CONDITION = EXPRESSION_FEATURE_COUNT + 2; |
| 493 | 514 | ||
| 494 | /** | 515 | /** |
| 495 | * The number of structural features of the '<em>Unnamed Object</em>' class. | 516 | * The number of structural features of the '<em>Aggregation</em>' class. |
| 496 | * <!-- begin-user-doc --> | 517 | * <!-- begin-user-doc --> |
| 497 | * <!-- end-user-doc --> | 518 | * <!-- end-user-doc --> |
| 498 | * @generated | 519 | * @generated |
| 499 | * @ordered | 520 | * @ordered |
| 500 | */ | 521 | */ |
| 501 | int UNNAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1; | 522 | int AGGREGATION_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 3; |
| 502 | 523 | ||
| 503 | /** | 524 | /** |
| 504 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl <em>Data Object</em>}' class. | 525 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl <em>Call</em>}' class. |
| 505 | * <!-- begin-user-doc --> | 526 | * <!-- begin-user-doc --> |
| 506 | * <!-- end-user-doc --> | 527 | * <!-- end-user-doc --> |
| 507 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl | 528 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl |
| 508 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject() | 529 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCall() |
| 509 | * @generated | 530 | * @generated |
| 510 | */ | 531 | */ |
| 511 | int DATA_OBJECT = 20; | 532 | int CALL = 13; |
| 512 | 533 | ||
| 513 | /** | 534 | /** |
| 514 | * The number of structural features of the '<em>Data Object</em>' class. | 535 | * The feature id for the '<em><b>Functor</b></em>' containment reference. |
| 515 | * <!-- begin-user-doc --> | 536 | * <!-- begin-user-doc --> |
| 516 | * <!-- end-user-doc --> | 537 | * <!-- end-user-doc --> |
| 517 | * @generated | 538 | * @generated |
| 518 | * @ordered | 539 | * @ordered |
| 519 | */ | 540 | */ |
| 520 | int DATA_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 0; | 541 | int CALL__FUNCTOR = EXPRESSION_FEATURE_COUNT + 0; |
| 521 | 542 | ||
| 522 | /** | 543 | /** |
| 523 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl <em>Boolean Object</em>}' class. | 544 | * The feature id for the '<em><b>Transitive Closure</b></em>' attribute. |
| 524 | * <!-- begin-user-doc --> | 545 | * <!-- begin-user-doc --> |
| 525 | * <!-- end-user-doc --> | 546 | * <!-- end-user-doc --> |
| 526 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl | ||
| 527 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject() | ||
| 528 | * @generated | 547 | * @generated |
| 548 | * @ordered | ||
| 529 | */ | 549 | */ |
| 530 | int BOOLEAN_OBJECT = 21; | 550 | int CALL__TRANSITIVE_CLOSURE = EXPRESSION_FEATURE_COUNT + 1; |
| 531 | 551 | ||
| 532 | /** | 552 | /** |
| 533 | * The feature id for the '<em><b>Value</b></em>' containment reference. | 553 | * The feature id for the '<em><b>Reflexive Transitive Closure</b></em>' attribute. |
| 534 | * <!-- begin-user-doc --> | 554 | * <!-- begin-user-doc --> |
| 535 | * <!-- end-user-doc --> | 555 | * <!-- end-user-doc --> |
| 536 | * @generated | 556 | * @generated |
| 537 | * @ordered | 557 | * @ordered |
| 538 | */ | 558 | */ |
| 539 | int BOOLEAN_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; | 559 | int CALL__REFLEXIVE_TRANSITIVE_CLOSURE = EXPRESSION_FEATURE_COUNT + 2; |
| 540 | 560 | ||
| 541 | /** | 561 | /** |
| 542 | * The number of structural features of the '<em>Boolean Object</em>' class. | 562 | * The feature id for the '<em><b>Argument List</b></em>' containment reference. |
| 543 | * <!-- begin-user-doc --> | 563 | * <!-- begin-user-doc --> |
| 544 | * <!-- end-user-doc --> | 564 | * <!-- end-user-doc --> |
| 545 | * @generated | 565 | * @generated |
| 546 | * @ordered | 566 | * @ordered |
| 547 | */ | 567 | */ |
| 548 | int BOOLEAN_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; | 568 | int CALL__ARGUMENT_LIST = EXPRESSION_FEATURE_COUNT + 3; |
| 549 | 569 | ||
| 550 | /** | 570 | /** |
| 551 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl <em>Int Object</em>}' class. | 571 | * The number of structural features of the '<em>Call</em>' class. |
| 552 | * <!-- begin-user-doc --> | 572 | * <!-- begin-user-doc --> |
| 553 | * <!-- end-user-doc --> | 573 | * <!-- end-user-doc --> |
| 554 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl | ||
| 555 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject() | ||
| 556 | * @generated | 574 | * @generated |
| 575 | * @ordered | ||
| 557 | */ | 576 | */ |
| 558 | int INT_OBJECT = 22; | 577 | int CALL_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 4; |
| 559 | 578 | ||
| 560 | /** | 579 | /** |
| 561 | * The feature id for the '<em><b>Value</b></em>' attribute. | 580 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentListImpl <em>Argument List</em>}' class. |
| 581 | * <!-- begin-user-doc --> | ||
| 582 | * <!-- end-user-doc --> | ||
| 583 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentListImpl | ||
| 584 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getArgumentList() | ||
| 585 | * @generated | ||
| 586 | */ | ||
| 587 | int ARGUMENT_LIST = 14; | ||
| 588 | |||
| 589 | /** | ||
| 590 | * The feature id for the '<em><b>Arguments</b></em>' containment reference list. | ||
| 562 | * <!-- begin-user-doc --> | 591 | * <!-- begin-user-doc --> |
| 563 | * <!-- end-user-doc --> | 592 | * <!-- end-user-doc --> |
| 564 | * @generated | 593 | * @generated |
| 565 | * @ordered | 594 | * @ordered |
| 566 | */ | 595 | */ |
| 567 | int INT_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; | 596 | int ARGUMENT_LIST__ARGUMENTS = 0; |
| 568 | 597 | ||
| 569 | /** | 598 | /** |
| 570 | * The number of structural features of the '<em>Int Object</em>' class. | 599 | * The number of structural features of the '<em>Argument List</em>' class. |
| 571 | * <!-- begin-user-doc --> | 600 | * <!-- begin-user-doc --> |
| 572 | * <!-- end-user-doc --> | 601 | * <!-- end-user-doc --> |
| 573 | * @generated | 602 | * @generated |
| 574 | * @ordered | 603 | * @ordered |
| 575 | */ | 604 | */ |
| 576 | int INT_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; | 605 | int ARGUMENT_LIST_FEATURE_COUNT = 1; |
| 577 | 606 | ||
| 578 | /** | 607 | /** |
| 579 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl <em>Real Object</em>}' class. | 608 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentImpl <em>Argument</em>}' class. |
| 580 | * <!-- begin-user-doc --> | 609 | * <!-- begin-user-doc --> |
| 581 | * <!-- end-user-doc --> | 610 | * <!-- end-user-doc --> |
| 582 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl | 611 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentImpl |
| 583 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject() | 612 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getArgument() |
| 584 | * @generated | 613 | * @generated |
| 585 | */ | 614 | */ |
| 586 | int REAL_OBJECT = 23; | 615 | int ARGUMENT = 15; |
| 587 | 616 | ||
| 588 | /** | 617 | /** |
| 589 | * The feature id for the '<em><b>Value</b></em>' attribute. | 618 | * The number of structural features of the '<em>Argument</em>' class. |
| 590 | * <!-- begin-user-doc --> | 619 | * <!-- begin-user-doc --> |
| 591 | * <!-- end-user-doc --> | 620 | * <!-- end-user-doc --> |
| 592 | * @generated | 621 | * @generated |
| 593 | * @ordered | 622 | * @ordered |
| 594 | */ | 623 | */ |
| 595 | int REAL_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; | 624 | int ARGUMENT_FEATURE_COUNT = 0; |
| 596 | 625 | ||
| 597 | /** | 626 | /** |
| 598 | * The number of structural features of the '<em>Real Object</em>' class. | 627 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionArgumentImpl <em>Expression Argument</em>}' class. |
| 599 | * <!-- begin-user-doc --> | 628 | * <!-- begin-user-doc --> |
| 600 | * <!-- end-user-doc --> | 629 | * <!-- end-user-doc --> |
| 630 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionArgumentImpl | ||
| 631 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExpressionArgument() | ||
| 601 | * @generated | 632 | * @generated |
| 602 | * @ordered | ||
| 603 | */ | 633 | */ |
| 604 | int REAL_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; | 634 | int EXPRESSION_ARGUMENT = 16; |
| 605 | 635 | ||
| 606 | /** | 636 | /** |
| 607 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl <em>String Object</em>}' class. | 637 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 608 | * <!-- begin-user-doc --> | 638 | * <!-- begin-user-doc --> |
| 609 | * <!-- end-user-doc --> | 639 | * <!-- end-user-doc --> |
| 610 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl | ||
| 611 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject() | ||
| 612 | * @generated | 640 | * @generated |
| 641 | * @ordered | ||
| 613 | */ | 642 | */ |
| 614 | int STRING_OBJECT = 24; | 643 | int EXPRESSION_ARGUMENT__BODY = ARGUMENT_FEATURE_COUNT + 0; |
| 615 | 644 | ||
| 616 | /** | 645 | /** |
| 617 | * The feature id for the '<em><b>Value</b></em>' attribute. | 646 | * The number of structural features of the '<em>Expression Argument</em>' class. |
| 618 | * <!-- begin-user-doc --> | 647 | * <!-- begin-user-doc --> |
| 619 | * <!-- end-user-doc --> | 648 | * <!-- end-user-doc --> |
| 620 | * @generated | 649 | * @generated |
| 621 | * @ordered | 650 | * @ordered |
| 622 | */ | 651 | */ |
| 623 | int STRING_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; | 652 | int EXPRESSION_ARGUMENT_FEATURE_COUNT = ARGUMENT_FEATURE_COUNT + 1; |
| 624 | 653 | ||
| 625 | /** | 654 | /** |
| 626 | * The number of structural features of the '<em>String Object</em>' class. | 655 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StarArgumentImpl <em>Star Argument</em>}' class. |
| 656 | * <!-- begin-user-doc --> | ||
| 657 | * <!-- end-user-doc --> | ||
| 658 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StarArgumentImpl | ||
| 659 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStarArgument() | ||
| 660 | * @generated | ||
| 661 | */ | ||
| 662 | int STAR_ARGUMENT = 17; | ||
| 663 | |||
| 664 | /** | ||
| 665 | * The number of structural features of the '<em>Star Argument</em>' class. | ||
| 627 | * <!-- begin-user-doc --> | 666 | * <!-- begin-user-doc --> |
| 628 | * <!-- end-user-doc --> | 667 | * <!-- end-user-doc --> |
| 629 | * @generated | 668 | * @generated |
| 630 | * @ordered | 669 | * @ordered |
| 631 | */ | 670 | */ |
| 632 | int STRING_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; | 671 | int STAR_ARGUMENT_FEATURE_COUNT = ARGUMENT_FEATURE_COUNT + 0; |
| 633 | 672 | ||
| 634 | /** | 673 | /** |
| 635 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl <em>Predicate</em>}' class. | 674 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl <em>Typed Argument</em>}' class. |
| 636 | * <!-- begin-user-doc --> | 675 | * <!-- begin-user-doc --> |
| 637 | * <!-- end-user-doc --> | 676 | * <!-- end-user-doc --> |
| 638 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl | 677 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl |
| 639 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate() | 678 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTypedArgument() |
| 640 | * @generated | 679 | * @generated |
| 641 | */ | 680 | */ |
| 642 | int PREDICATE = 25; | 681 | int TYPED_ARGUMENT = 18; |
| 643 | 682 | ||
| 644 | /** | 683 | /** |
| 645 | * The feature id for the '<em><b>Is Error</b></em>' attribute. | 684 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 646 | * <!-- begin-user-doc --> | 685 | * <!-- begin-user-doc --> |
| 647 | * <!-- end-user-doc --> | 686 | * <!-- end-user-doc --> |
| 648 | * @generated | 687 | * @generated |
| 649 | * @ordered | 688 | * @ordered |
| 650 | */ | 689 | */ |
| 651 | int PREDICATE__IS_ERROR = STATEMENT_FEATURE_COUNT + 0; | 690 | int TYPED_ARGUMENT__TYPE = ARGUMENT_FEATURE_COUNT + 0; |
| 652 | 691 | ||
| 653 | /** | 692 | /** |
| 654 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 693 | * The feature id for the '<em><b>Variable</b></em>' reference. |
| 655 | * <!-- begin-user-doc --> | 694 | * <!-- begin-user-doc --> |
| 656 | * <!-- end-user-doc --> | 695 | * <!-- end-user-doc --> |
| 657 | * @generated | 696 | * @generated |
| 658 | * @ordered | 697 | * @ordered |
| 659 | */ | 698 | */ |
| 660 | int PREDICATE__SYMBOL = STATEMENT_FEATURE_COUNT + 1; | 699 | int TYPED_ARGUMENT__VARIABLE = ARGUMENT_FEATURE_COUNT + 1; |
| 661 | 700 | ||
| 662 | /** | 701 | /** |
| 663 | * The feature id for the '<em><b>Parameters</b></em>' containment reference list. | 702 | * The number of structural features of the '<em>Typed Argument</em>' class. |
| 664 | * <!-- begin-user-doc --> | 703 | * <!-- begin-user-doc --> |
| 665 | * <!-- end-user-doc --> | 704 | * <!-- end-user-doc --> |
| 666 | * @generated | 705 | * @generated |
| 667 | * @ordered | 706 | * @ordered |
| 668 | */ | 707 | */ |
| 669 | int PREDICATE__PARAMETERS = STATEMENT_FEATURE_COUNT + 2; | 708 | int TYPED_ARGUMENT_FEATURE_COUNT = ARGUMENT_FEATURE_COUNT + 2; |
| 709 | |||
| 710 | /** | ||
| 711 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedStarArgumentImpl <em>Typed Star Argument</em>}' class. | ||
| 712 | * <!-- begin-user-doc --> | ||
| 713 | * <!-- end-user-doc --> | ||
| 714 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TypedStarArgumentImpl | ||
| 715 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTypedStarArgument() | ||
| 716 | * @generated | ||
| 717 | */ | ||
| 718 | int TYPED_STAR_ARGUMENT = 19; | ||
| 670 | 719 | ||
| 671 | /** | 720 | /** |
| 672 | * The feature id for the '<em><b>Bodies</b></em>' containment reference list. | 721 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 673 | * <!-- begin-user-doc --> | 722 | * <!-- begin-user-doc --> |
| 674 | * <!-- end-user-doc --> | 723 | * <!-- end-user-doc --> |
| 675 | * @generated | 724 | * @generated |
| 676 | * @ordered | 725 | * @ordered |
| 677 | */ | 726 | */ |
| 678 | int PREDICATE__BODIES = STATEMENT_FEATURE_COUNT + 3; | 727 | int TYPED_STAR_ARGUMENT__TYPE = ARGUMENT_FEATURE_COUNT + 0; |
| 679 | 728 | ||
| 680 | /** | 729 | /** |
| 681 | * The number of structural features of the '<em>Predicate</em>' class. | 730 | * The number of structural features of the '<em>Typed Star Argument</em>' class. |
| 682 | * <!-- begin-user-doc --> | 731 | * <!-- begin-user-doc --> |
| 683 | * <!-- end-user-doc --> | 732 | * <!-- end-user-doc --> |
| 684 | * @generated | 733 | * @generated |
| 685 | * @ordered | 734 | * @ordered |
| 686 | */ | 735 | */ |
| 687 | int PREDICATE_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 4; | 736 | int TYPED_STAR_ARGUMENT_FEATURE_COUNT = ARGUMENT_FEATURE_COUNT + 1; |
| 688 | 737 | ||
| 689 | /** | 738 | /** |
| 690 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl <em>Parameter</em>}' class. | 739 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReferenceImpl <em>Reference</em>}' class. |
| 691 | * <!-- begin-user-doc --> | 740 | * <!-- begin-user-doc --> |
| 692 | * <!-- end-user-doc --> | 741 | * <!-- end-user-doc --> |
| 693 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl | 742 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReferenceImpl |
| 694 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter() | 743 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReference() |
| 695 | * @generated | 744 | * @generated |
| 696 | */ | 745 | */ |
| 697 | int PARAMETER = 26; | 746 | int REFERENCE = 20; |
| 698 | 747 | ||
| 699 | /** | 748 | /** |
| 700 | * The feature id for the '<em><b>Variable</b></em>' containment reference. | 749 | * The feature id for the '<em><b>Referred</b></em>' reference. |
| 701 | * <!-- begin-user-doc --> | 750 | * <!-- begin-user-doc --> |
| 702 | * <!-- end-user-doc --> | 751 | * <!-- end-user-doc --> |
| 703 | * @generated | 752 | * @generated |
| 704 | * @ordered | 753 | * @ordered |
| 705 | */ | 754 | */ |
| 706 | int PARAMETER__VARIABLE = 0; | 755 | int REFERENCE__REFERRED = EXPRESSION_FEATURE_COUNT + 0; |
| 707 | 756 | ||
| 708 | /** | 757 | /** |
| 709 | * The feature id for the '<em><b>Type</b></em>' containment reference. | 758 | * The number of structural features of the '<em>Reference</em>' class. |
| 710 | * <!-- begin-user-doc --> | 759 | * <!-- begin-user-doc --> |
| 711 | * <!-- end-user-doc --> | 760 | * <!-- end-user-doc --> |
| 712 | * @generated | 761 | * @generated |
| 713 | * @ordered | 762 | * @ordered |
| 714 | */ | 763 | */ |
| 715 | int PARAMETER__TYPE = 1; | 764 | int REFERENCE_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 1; |
| 716 | 765 | ||
| 717 | /** | 766 | /** |
| 718 | * The number of structural features of the '<em>Parameter</em>' class. | 767 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl <em>Interval</em>}' class. |
| 719 | * <!-- begin-user-doc --> | 768 | * <!-- begin-user-doc --> |
| 720 | * <!-- end-user-doc --> | 769 | * <!-- end-user-doc --> |
| 770 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl | ||
| 771 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterval() | ||
| 721 | * @generated | 772 | * @generated |
| 722 | * @ordered | ||
| 723 | */ | 773 | */ |
| 724 | int PARAMETER_FEATURE_COUNT = 2; | 774 | int INTERVAL = 21; |
| 725 | 775 | ||
| 726 | /** | 776 | /** |
| 727 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl <em>Pattern Body</em>}' class. | 777 | * The feature id for the '<em><b>Lower Bound</b></em>' containment reference. |
| 728 | * <!-- begin-user-doc --> | 778 | * <!-- begin-user-doc --> |
| 729 | * <!-- end-user-doc --> | 779 | * <!-- end-user-doc --> |
| 730 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl | ||
| 731 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody() | ||
| 732 | * @generated | 780 | * @generated |
| 781 | * @ordered | ||
| 733 | */ | 782 | */ |
| 734 | int PATTERN_BODY = 27; | 783 | int INTERVAL__LOWER_BOUND = EXPRESSION_FEATURE_COUNT + 0; |
| 735 | 784 | ||
| 736 | /** | 785 | /** |
| 737 | * The feature id for the '<em><b>Constraints</b></em>' containment reference list. | 786 | * The feature id for the '<em><b>Upper Bound</b></em>' containment reference. |
| 738 | * <!-- begin-user-doc --> | 787 | * <!-- begin-user-doc --> |
| 739 | * <!-- end-user-doc --> | 788 | * <!-- end-user-doc --> |
| 740 | * @generated | 789 | * @generated |
| 741 | * @ordered | 790 | * @ordered |
| 742 | */ | 791 | */ |
| 743 | int PATTERN_BODY__CONSTRAINTS = 0; | 792 | int INTERVAL__UPPER_BOUND = EXPRESSION_FEATURE_COUNT + 1; |
| 744 | 793 | ||
| 745 | /** | 794 | /** |
| 746 | * The number of structural features of the '<em>Pattern Body</em>' class. | 795 | * The number of structural features of the '<em>Interval</em>' class. |
| 747 | * <!-- begin-user-doc --> | 796 | * <!-- begin-user-doc --> |
| 748 | * <!-- end-user-doc --> | 797 | * <!-- end-user-doc --> |
| 749 | * @generated | 798 | * @generated |
| 750 | * @ordered | 799 | * @ordered |
| 751 | */ | 800 | */ |
| 752 | int PATTERN_BODY_FEATURE_COUNT = 1; | 801 | int INTERVAL_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 2; |
| 753 | 802 | ||
| 754 | /** | 803 | /** |
| 755 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl <em>Polarity</em>}' class. | 804 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class. |
| 756 | * <!-- begin-user-doc --> | 805 | * <!-- begin-user-doc --> |
| 757 | * <!-- end-user-doc --> | 806 | * <!-- end-user-doc --> |
| 758 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl | 807 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl |
| 759 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity() | 808 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral() |
| 760 | * @generated | 809 | * @generated |
| 761 | */ | 810 | */ |
| 762 | int POLARITY = 28; | 811 | int LITERAL = 22; |
| 763 | 812 | ||
| 764 | /** | 813 | /** |
| 765 | * The number of structural features of the '<em>Polarity</em>' class. | 814 | * The number of structural features of the '<em>Literal</em>' class. |
| 766 | * <!-- begin-user-doc --> | 815 | * <!-- begin-user-doc --> |
| 767 | * <!-- end-user-doc --> | 816 | * <!-- end-user-doc --> |
| 768 | * @generated | 817 | * @generated |
| 769 | * @ordered | 818 | * @ordered |
| 770 | */ | 819 | */ |
| 771 | int POLARITY_FEATURE_COUNT = 0; | 820 | int LITERAL_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 0; |
| 772 | 821 | ||
| 773 | /** | 822 | /** |
| 774 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl <em>Constraint</em>}' class. | 823 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LogicLiteralImpl <em>Logic Literal</em>}' class. |
| 775 | * <!-- begin-user-doc --> | 824 | * <!-- begin-user-doc --> |
| 776 | * <!-- end-user-doc --> | 825 | * <!-- end-user-doc --> |
| 777 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl | 826 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LogicLiteralImpl |
| 778 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint() | 827 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLogicLiteral() |
| 779 | * @generated | 828 | * @generated |
| 780 | */ | 829 | */ |
| 781 | int CONSTRAINT = 29; | 830 | int LOGIC_LITERAL = 23; |
| 782 | 831 | ||
| 783 | /** | 832 | /** |
| 784 | * The feature id for the '<em><b>Polarity</b></em>' containment reference. | 833 | * The feature id for the '<em><b>Value</b></em>' attribute. |
| 785 | * <!-- begin-user-doc --> | 834 | * <!-- begin-user-doc --> |
| 786 | * <!-- end-user-doc --> | 835 | * <!-- end-user-doc --> |
| 787 | * @generated | 836 | * @generated |
| 788 | * @ordered | 837 | * @ordered |
| 789 | */ | 838 | */ |
| 790 | int CONSTRAINT__POLARITY = 0; | 839 | int LOGIC_LITERAL__VALUE = LITERAL_FEATURE_COUNT + 0; |
| 791 | 840 | ||
| 792 | /** | 841 | /** |
| 793 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 842 | * The number of structural features of the '<em>Logic Literal</em>' class. |
| 794 | * <!-- begin-user-doc --> | 843 | * <!-- begin-user-doc --> |
| 795 | * <!-- end-user-doc --> | 844 | * <!-- end-user-doc --> |
| 796 | * @generated | 845 | * @generated |
| 797 | * @ordered | 846 | * @ordered |
| 798 | */ | 847 | */ |
| 799 | int CONSTRAINT__SYMBOL = 1; | 848 | int LOGIC_LITERAL_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1; |
| 800 | 849 | ||
| 801 | /** | 850 | /** |
| 802 | * The feature id for the '<em><b>Params</b></em>' containment reference list. | 851 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NumericLiteralImpl <em>Numeric Literal</em>}' class. |
| 803 | * <!-- begin-user-doc --> | 852 | * <!-- begin-user-doc --> |
| 804 | * <!-- end-user-doc --> | 853 | * <!-- end-user-doc --> |
| 854 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NumericLiteralImpl | ||
| 855 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNumericLiteral() | ||
| 805 | * @generated | 856 | * @generated |
| 806 | * @ordered | ||
| 807 | */ | 857 | */ |
| 808 | int CONSTRAINT__PARAMS = 2; | 858 | int NUMERIC_LITERAL = 24; |
| 809 | 859 | ||
| 810 | /** | 860 | /** |
| 811 | * The feature id for the '<em><b>Closure Type</b></em>' containment reference. | 861 | * The feature id for the '<em><b>Value</b></em>' attribute. |
| 812 | * <!-- begin-user-doc --> | 862 | * <!-- begin-user-doc --> |
| 813 | * <!-- end-user-doc --> | 863 | * <!-- end-user-doc --> |
| 814 | * @generated | 864 | * @generated |
| 815 | * @ordered | 865 | * @ordered |
| 816 | */ | 866 | */ |
| 817 | int CONSTRAINT__CLOSURE_TYPE = 3; | 867 | int NUMERIC_LITERAL__VALUE = LITERAL_FEATURE_COUNT + 0; |
| 818 | 868 | ||
| 819 | /** | 869 | /** |
| 820 | * The number of structural features of the '<em>Constraint</em>' class. | 870 | * The number of structural features of the '<em>Numeric Literal</em>' class. |
| 821 | * <!-- begin-user-doc --> | 871 | * <!-- begin-user-doc --> |
| 822 | * <!-- end-user-doc --> | 872 | * <!-- end-user-doc --> |
| 823 | * @generated | 873 | * @generated |
| 824 | * @ordered | 874 | * @ordered |
| 825 | */ | 875 | */ |
| 826 | int CONSTRAINT_FEATURE_COUNT = 4; | 876 | int NUMERIC_LITERAL_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1; |
| 827 | 877 | ||
| 828 | /** | 878 | /** |
| 829 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl <em>Closure Type</em>}' class. | 879 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InfinityLiteralImpl <em>Infinity Literal</em>}' class. |
| 830 | * <!-- begin-user-doc --> | 880 | * <!-- begin-user-doc --> |
| 831 | * <!-- end-user-doc --> | 881 | * <!-- end-user-doc --> |
| 832 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl | 882 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InfinityLiteralImpl |
| 833 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType() | 883 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInfinityLiteral() |
| 834 | * @generated | 884 | * @generated |
| 835 | */ | 885 | */ |
| 836 | int CLOSURE_TYPE = 30; | 886 | int INFINITY_LITERAL = 25; |
| 837 | 887 | ||
| 838 | /** | 888 | /** |
| 839 | * The number of structural features of the '<em>Closure Type</em>' class. | 889 | * The number of structural features of the '<em>Infinity Literal</em>' class. |
| 840 | * <!-- begin-user-doc --> | 890 | * <!-- begin-user-doc --> |
| 841 | * <!-- end-user-doc --> | 891 | * <!-- end-user-doc --> |
| 842 | * @generated | 892 | * @generated |
| 843 | * @ordered | 893 | * @ordered |
| 844 | */ | 894 | */ |
| 845 | int CLOSURE_TYPE_FEATURE_COUNT = 0; | 895 | int INFINITY_LITERAL_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 0; |
| 846 | 896 | ||
| 847 | /** | 897 | /** |
| 848 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class. | 898 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EmptyIntervalLiteralImpl <em>Empty Interval Literal</em>}' class. |
| 849 | * <!-- begin-user-doc --> | 899 | * <!-- begin-user-doc --> |
| 850 | * <!-- end-user-doc --> | 900 | * <!-- end-user-doc --> |
| 851 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl | 901 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EmptyIntervalLiteralImpl |
| 852 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral() | 902 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEmptyIntervalLiteral() |
| 853 | * @generated | 903 | * @generated |
| 854 | */ | 904 | */ |
| 855 | int LITERAL = 31; | 905 | int EMPTY_INTERVAL_LITERAL = 26; |
| 856 | 906 | ||
| 857 | /** | 907 | /** |
| 858 | * The number of structural features of the '<em>Literal</em>' class. | 908 | * The number of structural features of the '<em>Empty Interval Literal</em>' class. |
| 859 | * <!-- begin-user-doc --> | 909 | * <!-- begin-user-doc --> |
| 860 | * <!-- end-user-doc --> | 910 | * <!-- end-user-doc --> |
| 861 | * @generated | 911 | * @generated |
| 862 | * @ordered | 912 | * @ordered |
| 863 | */ | 913 | */ |
| 864 | int LITERAL_FEATURE_COUNT = 0; | 914 | int EMPTY_INTERVAL_LITERAL_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 0; |
| 865 | 915 | ||
| 866 | /** | 916 | /** |
| 867 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl <em>Variable</em>}' class. | 917 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringLiteralImpl <em>String Literal</em>}' class. |
| 868 | * <!-- begin-user-doc --> | 918 | * <!-- begin-user-doc --> |
| 869 | * <!-- end-user-doc --> | 919 | * <!-- end-user-doc --> |
| 870 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl | 920 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringLiteralImpl |
| 871 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable() | 921 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringLiteral() |
| 872 | * @generated | 922 | * @generated |
| 873 | */ | 923 | */ |
| 874 | int VARIABLE = 32; | 924 | int STRING_LITERAL = 27; |
| 875 | 925 | ||
| 876 | /** | 926 | /** |
| 877 | * The feature id for the '<em><b>Name</b></em>' attribute. | 927 | * The feature id for the '<em><b>Value</b></em>' attribute. |
| 878 | * <!-- begin-user-doc --> | 928 | * <!-- begin-user-doc --> |
| 879 | * <!-- end-user-doc --> | 929 | * <!-- end-user-doc --> |
| 880 | * @generated | 930 | * @generated |
| 881 | * @ordered | 931 | * @ordered |
| 882 | */ | 932 | */ |
| 883 | int VARIABLE__NAME = LITERAL_FEATURE_COUNT + 0; | 933 | int STRING_LITERAL__VALUE = LITERAL_FEATURE_COUNT + 0; |
| 884 | 934 | ||
| 885 | /** | 935 | /** |
| 886 | * The number of structural features of the '<em>Variable</em>' class. | 936 | * The number of structural features of the '<em>String Literal</em>' class. |
| 887 | * <!-- begin-user-doc --> | 937 | * <!-- begin-user-doc --> |
| 888 | * <!-- end-user-doc --> | 938 | * <!-- end-user-doc --> |
| 889 | * @generated | 939 | * @generated |
| 890 | * @ordered | 940 | * @ordered |
| 891 | */ | 941 | */ |
| 892 | int VARIABLE_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1; | 942 | int STRING_LITERAL_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1; |
| 943 | |||
| 944 | /** | ||
| 945 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl <em>Class Definition</em>}' class. | ||
| 946 | * <!-- begin-user-doc --> | ||
| 947 | * <!-- end-user-doc --> | ||
| 948 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl | ||
| 949 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassDefinition() | ||
| 950 | * @generated | ||
| 951 | */ | ||
| 952 | int CLASS_DEFINITION = 28; | ||
| 893 | 953 | ||
| 894 | /** | 954 | /** |
| 895 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl <em>All Instances</em>}' class. | 955 | * The feature id for the '<em><b>Abstract</b></em>' attribute. |
| 896 | * <!-- begin-user-doc --> | 956 | * <!-- begin-user-doc --> |
| 897 | * <!-- end-user-doc --> | 957 | * <!-- end-user-doc --> |
| 898 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl | ||
| 899 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances() | ||
| 900 | * @generated | 958 | * @generated |
| 959 | * @ordered | ||
| 901 | */ | 960 | */ |
| 902 | int ALL_INSTANCES = 33; | 961 | int CLASS_DEFINITION__ABSTRACT = STATEMENT_FEATURE_COUNT + 0; |
| 903 | 962 | ||
| 904 | /** | 963 | /** |
| 905 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 964 | * The feature id for the '<em><b>Name</b></em>' attribute. |
| 906 | * <!-- begin-user-doc --> | 965 | * <!-- begin-user-doc --> |
| 907 | * <!-- end-user-doc --> | 966 | * <!-- end-user-doc --> |
| 908 | * @generated | 967 | * @generated |
| 909 | * @ordered | 968 | * @ordered |
| 910 | */ | 969 | */ |
| 911 | int ALL_INSTANCES__SYMBOL = COMPLEX_OBJECT_FEATURE_COUNT + 0; | 970 | int CLASS_DEFINITION__NAME = STATEMENT_FEATURE_COUNT + 1; |
| 912 | 971 | ||
| 913 | /** | 972 | /** |
| 914 | * The number of structural features of the '<em>All Instances</em>' class. | 973 | * The feature id for the '<em><b>Superclasses</b></em>' reference list. |
| 915 | * <!-- begin-user-doc --> | 974 | * <!-- begin-user-doc --> |
| 916 | * <!-- end-user-doc --> | 975 | * <!-- end-user-doc --> |
| 917 | * @generated | 976 | * @generated |
| 918 | * @ordered | 977 | * @ordered |
| 919 | */ | 978 | */ |
| 920 | int ALL_INSTANCES_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 1; | 979 | int CLASS_DEFINITION__SUPERCLASSES = STATEMENT_FEATURE_COUNT + 2; |
| 921 | 980 | ||
| 922 | /** | 981 | /** |
| 923 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl <em>All Objects</em>}' class. | 982 | * The feature id for the '<em><b>Members</b></em>' containment reference list. |
| 924 | * <!-- begin-user-doc --> | 983 | * <!-- begin-user-doc --> |
| 925 | * <!-- end-user-doc --> | 984 | * <!-- end-user-doc --> |
| 926 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl | ||
| 927 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects() | ||
| 928 | * @generated | 985 | * @generated |
| 986 | * @ordered | ||
| 929 | */ | 987 | */ |
| 930 | int ALL_OBJECTS = 34; | 988 | int CLASS_DEFINITION__MEMBERS = STATEMENT_FEATURE_COUNT + 3; |
| 931 | 989 | ||
| 932 | /** | 990 | /** |
| 933 | * The number of structural features of the '<em>All Objects</em>' class. | 991 | * The number of structural features of the '<em>Class Definition</em>' class. |
| 934 | * <!-- begin-user-doc --> | 992 | * <!-- begin-user-doc --> |
| 935 | * <!-- end-user-doc --> | 993 | * <!-- end-user-doc --> |
| 936 | * @generated | 994 | * @generated |
| 937 | * @ordered | 995 | * @ordered |
| 938 | */ | 996 | */ |
| 939 | int ALL_OBJECTS_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0; | 997 | int CLASS_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 4; |
| 940 | 998 | ||
| 941 | /** | 999 | /** |
| 942 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl <em>Default Interpretation</em>}' class. | 1000 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl <em>Member Definition</em>}' class. |
| 943 | * <!-- begin-user-doc --> | 1001 | * <!-- begin-user-doc --> |
| 944 | * <!-- end-user-doc --> | 1002 | * <!-- end-user-doc --> |
| 945 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl | 1003 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl |
| 946 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation() | 1004 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMemberDefinition() |
| 947 | * @generated | 1005 | * @generated |
| 948 | */ | 1006 | */ |
| 949 | int DEFAULT_INTERPRETATION = 35; | 1007 | int MEMBER_DEFINITION = 29; |
| 950 | 1008 | ||
| 951 | /** | 1009 | /** |
| 952 | * The feature id for the '<em><b>Interpretation</b></em>' containment reference. | 1010 | * The feature id for the '<em><b>Containment</b></em>' attribute. |
| 953 | * <!-- begin-user-doc --> | 1011 | * <!-- begin-user-doc --> |
| 954 | * <!-- end-user-doc --> | 1012 | * <!-- end-user-doc --> |
| 955 | * @generated | 1013 | * @generated |
| 956 | * @ordered | 1014 | * @ordered |
| 957 | */ | 1015 | */ |
| 958 | int DEFAULT_INTERPRETATION__INTERPRETATION = INTERPRETATION_FEATURE_COUNT + 0; | 1016 | int MEMBER_DEFINITION__CONTAINMENT = 0; |
| 959 | 1017 | ||
| 960 | /** | 1018 | /** |
| 961 | * The number of structural features of the '<em>Default Interpretation</em>' class. | 1019 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 962 | * <!-- begin-user-doc --> | 1020 | * <!-- begin-user-doc --> |
| 963 | * <!-- end-user-doc --> | 1021 | * <!-- end-user-doc --> |
| 964 | * @generated | 1022 | * @generated |
| 965 | * @ordered | 1023 | * @ordered |
| 966 | */ | 1024 | */ |
| 967 | int DEFAULT_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 1; | 1025 | int MEMBER_DEFINITION__TYPE = 1; |
| 968 | 1026 | ||
| 969 | /** | 1027 | /** |
| 970 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl <em>CD Interpretation</em>}' class. | 1028 | * The feature id for the '<em><b>Multiplicity</b></em>' containment reference. |
| 971 | * <!-- begin-user-doc --> | 1029 | * <!-- begin-user-doc --> |
| 972 | * <!-- end-user-doc --> | 1030 | * <!-- end-user-doc --> |
| 973 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl | ||
| 974 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation() | ||
| 975 | * @generated | 1031 | * @generated |
| 1032 | * @ordered | ||
| 976 | */ | 1033 | */ |
| 977 | int CD_INTERPRETATION = 36; | 1034 | int MEMBER_DEFINITION__MULTIPLICITY = 2; |
| 978 | 1035 | ||
| 979 | /** | 1036 | /** |
| 980 | * The number of structural features of the '<em>CD Interpretation</em>' class. | 1037 | * The feature id for the '<em><b>Name</b></em>' attribute. |
| 981 | * <!-- begin-user-doc --> | 1038 | * <!-- begin-user-doc --> |
| 982 | * <!-- end-user-doc --> | 1039 | * <!-- end-user-doc --> |
| 983 | * @generated | 1040 | * @generated |
| 984 | * @ordered | 1041 | * @ordered |
| 985 | */ | 1042 | */ |
| 986 | int CD_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 0; | 1043 | int MEMBER_DEFINITION__NAME = 3; |
| 987 | 1044 | ||
| 988 | /** | 1045 | /** |
| 989 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl <em>Class Interpretation</em>}' class. | 1046 | * The feature id for the '<em><b>Opposite</b></em>' reference. |
| 990 | * <!-- begin-user-doc --> | 1047 | * <!-- begin-user-doc --> |
| 991 | * <!-- end-user-doc --> | 1048 | * <!-- end-user-doc --> |
| 992 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl | ||
| 993 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation() | ||
| 994 | * @generated | 1049 | * @generated |
| 1050 | * @ordered | ||
| 995 | */ | 1051 | */ |
| 996 | int CLASS_INTERPRETATION = 37; | 1052 | int MEMBER_DEFINITION__OPPOSITE = 4; |
| 997 | 1053 | ||
| 998 | /** | 1054 | /** |
| 999 | * The feature id for the '<em><b>Abstract</b></em>' attribute. | 1055 | * The number of structural features of the '<em>Member Definition</em>' class. |
| 1000 | * <!-- begin-user-doc --> | 1056 | * <!-- begin-user-doc --> |
| 1001 | * <!-- end-user-doc --> | 1057 | * <!-- end-user-doc --> |
| 1002 | * @generated | 1058 | * @generated |
| 1003 | * @ordered | 1059 | * @ordered |
| 1004 | */ | 1060 | */ |
| 1005 | int CLASS_INTERPRETATION__ABSTRACT = CD_INTERPRETATION_FEATURE_COUNT + 0; | 1061 | int MEMBER_DEFINITION_FEATURE_COUNT = 5; |
| 1062 | |||
| 1063 | /** | ||
| 1064 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityImpl <em>Multiplicity</em>}' class. | ||
| 1065 | * <!-- begin-user-doc --> | ||
| 1066 | * <!-- end-user-doc --> | ||
| 1067 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityImpl | ||
| 1068 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicity() | ||
| 1069 | * @generated | ||
| 1070 | */ | ||
| 1071 | int MULTIPLICITY = 30; | ||
| 1006 | 1072 | ||
| 1007 | /** | 1073 | /** |
| 1008 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 1074 | * The number of structural features of the '<em>Multiplicity</em>' class. |
| 1009 | * <!-- begin-user-doc --> | 1075 | * <!-- begin-user-doc --> |
| 1010 | * <!-- end-user-doc --> | 1076 | * <!-- end-user-doc --> |
| 1011 | * @generated | 1077 | * @generated |
| 1012 | * @ordered | 1078 | * @ordered |
| 1013 | */ | 1079 | */ |
| 1014 | int CLASS_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1; | 1080 | int MULTIPLICITY_FEATURE_COUNT = 0; |
| 1015 | 1081 | ||
| 1016 | /** | 1082 | /** |
| 1017 | * The feature id for the '<em><b>Supertypes</b></em>' containment reference list. | 1083 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ManyMultiplicityImpl <em>Many Multiplicity</em>}' class. |
| 1084 | * <!-- begin-user-doc --> | ||
| 1085 | * <!-- end-user-doc --> | ||
| 1086 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ManyMultiplicityImpl | ||
| 1087 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getManyMultiplicity() | ||
| 1088 | * @generated | ||
| 1089 | */ | ||
| 1090 | int MANY_MULTIPLICITY = 31; | ||
| 1091 | |||
| 1092 | /** | ||
| 1093 | * The number of structural features of the '<em>Many Multiplicity</em>' class. | ||
| 1018 | * <!-- begin-user-doc --> | 1094 | * <!-- begin-user-doc --> |
| 1019 | * <!-- end-user-doc --> | 1095 | * <!-- end-user-doc --> |
| 1020 | * @generated | 1096 | * @generated |
| 1021 | * @ordered | 1097 | * @ordered |
| 1022 | */ | 1098 | */ |
| 1023 | int CLASS_INTERPRETATION__SUPERTYPES = CD_INTERPRETATION_FEATURE_COUNT + 2; | 1099 | int MANY_MULTIPLICITY_FEATURE_COUNT = MULTIPLICITY_FEATURE_COUNT + 0; |
| 1024 | 1100 | ||
| 1025 | /** | 1101 | /** |
| 1026 | * The feature id for the '<em><b>Fielt</b></em>' containment reference list. | 1102 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactMultiplicityImpl <em>Exact Multiplicity</em>}' class. |
| 1103 | * <!-- begin-user-doc --> | ||
| 1104 | * <!-- end-user-doc --> | ||
| 1105 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExactMultiplicityImpl | ||
| 1106 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExactMultiplicity() | ||
| 1107 | * @generated | ||
| 1108 | */ | ||
| 1109 | int EXACT_MULTIPLICITY = 32; | ||
| 1110 | |||
| 1111 | /** | ||
| 1112 | * The feature id for the '<em><b>Multiplicity</b></em>' attribute. | ||
| 1027 | * <!-- begin-user-doc --> | 1113 | * <!-- begin-user-doc --> |
| 1028 | * <!-- end-user-doc --> | 1114 | * <!-- end-user-doc --> |
| 1029 | * @generated | 1115 | * @generated |
| 1030 | * @ordered | 1116 | * @ordered |
| 1031 | */ | 1117 | */ |
| 1032 | int CLASS_INTERPRETATION__FIELT = CD_INTERPRETATION_FEATURE_COUNT + 3; | 1118 | int EXACT_MULTIPLICITY__MULTIPLICITY = MULTIPLICITY_FEATURE_COUNT + 0; |
| 1033 | 1119 | ||
| 1034 | /** | 1120 | /** |
| 1035 | * The number of structural features of the '<em>Class Interpretation</em>' class. | 1121 | * The number of structural features of the '<em>Exact Multiplicity</em>' class. |
| 1036 | * <!-- begin-user-doc --> | 1122 | * <!-- begin-user-doc --> |
| 1037 | * <!-- end-user-doc --> | 1123 | * <!-- end-user-doc --> |
| 1038 | * @generated | 1124 | * @generated |
| 1039 | * @ordered | 1125 | * @ordered |
| 1040 | */ | 1126 | */ |
| 1041 | int CLASS_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 4; | 1127 | int EXACT_MULTIPLICITY_FEATURE_COUNT = MULTIPLICITY_FEATURE_COUNT + 1; |
| 1042 | 1128 | ||
| 1043 | /** | 1129 | /** |
| 1044 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl <em>Enum Interpretation</em>}' class. | 1130 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl <em>Bounded Multiplicity</em>}' class. |
| 1045 | * <!-- begin-user-doc --> | 1131 | * <!-- begin-user-doc --> |
| 1046 | * <!-- end-user-doc --> | 1132 | * <!-- end-user-doc --> |
| 1047 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl | 1133 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl |
| 1048 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation() | 1134 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBoundedMultiplicity() |
| 1049 | * @generated | 1135 | * @generated |
| 1050 | */ | 1136 | */ |
| 1051 | int ENUM_INTERPRETATION = 38; | 1137 | int BOUNDED_MULTIPLICITY = 33; |
| 1052 | 1138 | ||
| 1053 | /** | 1139 | /** |
| 1054 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 1140 | * The feature id for the '<em><b>Lower Bound</b></em>' attribute. |
| 1055 | * <!-- begin-user-doc --> | 1141 | * <!-- begin-user-doc --> |
| 1056 | * <!-- end-user-doc --> | 1142 | * <!-- end-user-doc --> |
| 1057 | * @generated | 1143 | * @generated |
| 1058 | * @ordered | 1144 | * @ordered |
| 1059 | */ | 1145 | */ |
| 1060 | int ENUM_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 0; | 1146 | int BOUNDED_MULTIPLICITY__LOWER_BOUND = MULTIPLICITY_FEATURE_COUNT + 0; |
| 1061 | 1147 | ||
| 1062 | /** | 1148 | /** |
| 1063 | * The feature id for the '<em><b>Objects</b></em>' containment reference list. | 1149 | * The feature id for the '<em><b>Upper Bound</b></em>' attribute. |
| 1064 | * <!-- begin-user-doc --> | 1150 | * <!-- begin-user-doc --> |
| 1065 | * <!-- end-user-doc --> | 1151 | * <!-- end-user-doc --> |
| 1066 | * @generated | 1152 | * @generated |
| 1067 | * @ordered | 1153 | * @ordered |
| 1068 | */ | 1154 | */ |
| 1069 | int ENUM_INTERPRETATION__OBJECTS = CD_INTERPRETATION_FEATURE_COUNT + 1; | 1155 | int BOUNDED_MULTIPLICITY__UPPER_BOUND = MULTIPLICITY_FEATURE_COUNT + 1; |
| 1070 | 1156 | ||
| 1071 | /** | 1157 | /** |
| 1072 | * The number of structural features of the '<em>Enum Interpretation</em>' class. | 1158 | * The number of structural features of the '<em>Bounded Multiplicity</em>' class. |
| 1073 | * <!-- begin-user-doc --> | 1159 | * <!-- begin-user-doc --> |
| 1074 | * <!-- end-user-doc --> | 1160 | * <!-- end-user-doc --> |
| 1075 | * @generated | 1161 | * @generated |
| 1076 | * @ordered | 1162 | * @ordered |
| 1077 | */ | 1163 | */ |
| 1078 | int ENUM_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 2; | 1164 | int BOUNDED_MULTIPLICITY_FEATURE_COUNT = MULTIPLICITY_FEATURE_COUNT + 2; |
| 1079 | 1165 | ||
| 1080 | /** | 1166 | /** |
| 1081 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl <em>Field Relation Interpretation</em>}' class. | 1167 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ScopeDefinitionImpl <em>Scope Definition</em>}' class. |
| 1082 | * <!-- begin-user-doc --> | 1168 | * <!-- begin-user-doc --> |
| 1083 | * <!-- end-user-doc --> | 1169 | * <!-- end-user-doc --> |
| 1084 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl | 1170 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ScopeDefinitionImpl |
| 1085 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation() | 1171 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getScopeDefinition() |
| 1086 | * @generated | 1172 | * @generated |
| 1087 | */ | 1173 | */ |
| 1088 | int FIELD_RELATION_INTERPRETATION = 39; | 1174 | int SCOPE_DEFINITION = 34; |
| 1089 | 1175 | ||
| 1090 | /** | 1176 | /** |
| 1091 | * The feature id for the '<em><b>Containment</b></em>' attribute. | 1177 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 1092 | * <!-- begin-user-doc --> | 1178 | * <!-- begin-user-doc --> |
| 1093 | * <!-- end-user-doc --> | 1179 | * <!-- end-user-doc --> |
| 1094 | * @generated | 1180 | * @generated |
| 1095 | * @ordered | 1181 | * @ordered |
| 1096 | */ | 1182 | */ |
| 1097 | int FIELD_RELATION_INTERPRETATION__CONTAINMENT = 0; | 1183 | int SCOPE_DEFINITION__TYPE = STATEMENT_FEATURE_COUNT + 0; |
| 1098 | 1184 | ||
| 1099 | /** | 1185 | /** |
| 1100 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 1186 | * The number of structural features of the '<em>Scope Definition</em>' class. |
| 1101 | * <!-- begin-user-doc --> | 1187 | * <!-- begin-user-doc --> |
| 1102 | * <!-- end-user-doc --> | 1188 | * <!-- end-user-doc --> |
| 1103 | * @generated | 1189 | * @generated |
| 1104 | * @ordered | 1190 | * @ordered |
| 1105 | */ | 1191 | */ |
| 1106 | int FIELD_RELATION_INTERPRETATION__SYMBOL = 1; | 1192 | int SCOPE_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 1; |
| 1107 | 1193 | ||
| 1108 | /** | 1194 | /** |
| 1109 | * The feature id for the '<em><b>Multiplicity</b></em>' containment reference. | 1195 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactScopeDefinitionImpl <em>Exact Scope Definition</em>}' class. |
| 1196 | * <!-- begin-user-doc --> | ||
| 1197 | * <!-- end-user-doc --> | ||
| 1198 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExactScopeDefinitionImpl | ||
| 1199 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExactScopeDefinition() | ||
| 1200 | * @generated | ||
| 1201 | */ | ||
| 1202 | int EXACT_SCOPE_DEFINITION = 35; | ||
| 1203 | |||
| 1204 | /** | ||
| 1205 | * The feature id for the '<em><b>Type</b></em>' reference. | ||
| 1110 | * <!-- begin-user-doc --> | 1206 | * <!-- begin-user-doc --> |
| 1111 | * <!-- end-user-doc --> | 1207 | * <!-- end-user-doc --> |
| 1112 | * @generated | 1208 | * @generated |
| 1113 | * @ordered | 1209 | * @ordered |
| 1114 | */ | 1210 | */ |
| 1115 | int FIELD_RELATION_INTERPRETATION__MULTIPLICITY = 2; | 1211 | int EXACT_SCOPE_DEFINITION__TYPE = SCOPE_DEFINITION__TYPE; |
| 1116 | 1212 | ||
| 1117 | /** | 1213 | /** |
| 1118 | * The feature id for the '<em><b>Target</b></em>' containment reference. | 1214 | * The feature id for the '<em><b>Exact Scope</b></em>' attribute. |
| 1119 | * <!-- begin-user-doc --> | 1215 | * <!-- begin-user-doc --> |
| 1120 | * <!-- end-user-doc --> | 1216 | * <!-- end-user-doc --> |
| 1121 | * @generated | 1217 | * @generated |
| 1122 | * @ordered | 1218 | * @ordered |
| 1123 | */ | 1219 | */ |
| 1124 | int FIELD_RELATION_INTERPRETATION__TARGET = 3; | 1220 | int EXACT_SCOPE_DEFINITION__EXACT_SCOPE = SCOPE_DEFINITION_FEATURE_COUNT + 0; |
| 1125 | 1221 | ||
| 1126 | /** | 1222 | /** |
| 1127 | * The number of structural features of the '<em>Field Relation Interpretation</em>' class. | 1223 | * The number of structural features of the '<em>Exact Scope Definition</em>' class. |
| 1128 | * <!-- begin-user-doc --> | 1224 | * <!-- begin-user-doc --> |
| 1129 | * <!-- end-user-doc --> | 1225 | * <!-- end-user-doc --> |
| 1130 | * @generated | 1226 | * @generated |
| 1131 | * @ordered | 1227 | * @ordered |
| 1132 | */ | 1228 | */ |
| 1133 | int FIELD_RELATION_INTERPRETATION_FEATURE_COUNT = 4; | 1229 | int EXACT_SCOPE_DEFINITION_FEATURE_COUNT = SCOPE_DEFINITION_FEATURE_COUNT + 1; |
| 1134 | 1230 | ||
| 1135 | /** | 1231 | /** |
| 1136 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl <em>Global Relation Interpretation</em>}' class. | 1232 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl <em>Bounded Scope Definition</em>}' class. |
| 1137 | * <!-- begin-user-doc --> | 1233 | * <!-- begin-user-doc --> |
| 1138 | * <!-- end-user-doc --> | 1234 | * <!-- end-user-doc --> |
| 1139 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl | 1235 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl |
| 1140 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation() | 1236 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBoundedScopeDefinition() |
| 1141 | * @generated | 1237 | * @generated |
| 1142 | */ | 1238 | */ |
| 1143 | int GLOBAL_RELATION_INTERPRETATION = 40; | 1239 | int BOUNDED_SCOPE_DEFINITION = 36; |
| 1144 | 1240 | ||
| 1145 | /** | 1241 | /** |
| 1146 | * The feature id for the '<em><b>Containment</b></em>' attribute. | 1242 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 1147 | * <!-- begin-user-doc --> | 1243 | * <!-- begin-user-doc --> |
| 1148 | * <!-- end-user-doc --> | 1244 | * <!-- end-user-doc --> |
| 1149 | * @generated | 1245 | * @generated |
| 1150 | * @ordered | 1246 | * @ordered |
| 1151 | */ | 1247 | */ |
| 1152 | int GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = CD_INTERPRETATION_FEATURE_COUNT + 0; | 1248 | int BOUNDED_SCOPE_DEFINITION__TYPE = SCOPE_DEFINITION__TYPE; |
| 1153 | 1249 | ||
| 1154 | /** | 1250 | /** |
| 1155 | * The feature id for the '<em><b>Symbol</b></em>' containment reference. | 1251 | * The feature id for the '<em><b>Lower Bound</b></em>' attribute. |
| 1156 | * <!-- begin-user-doc --> | 1252 | * <!-- begin-user-doc --> |
| 1157 | * <!-- end-user-doc --> | 1253 | * <!-- end-user-doc --> |
| 1158 | * @generated | 1254 | * @generated |
| 1159 | * @ordered | 1255 | * @ordered |
| 1160 | */ | 1256 | */ |
| 1161 | int GLOBAL_RELATION_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1; | 1257 | int BOUNDED_SCOPE_DEFINITION__LOWER_BOUND = SCOPE_DEFINITION_FEATURE_COUNT + 0; |
| 1162 | 1258 | ||
| 1163 | /** | 1259 | /** |
| 1164 | * The feature id for the '<em><b>Source Multiplicity</b></em>' containment reference. | 1260 | * The feature id for the '<em><b>Upper Bound</b></em>' attribute. |
| 1165 | * <!-- begin-user-doc --> | 1261 | * <!-- begin-user-doc --> |
| 1166 | * <!-- end-user-doc --> | 1262 | * <!-- end-user-doc --> |
| 1167 | * @generated | 1263 | * @generated |
| 1168 | * @ordered | 1264 | * @ordered |
| 1169 | */ | 1265 | */ |
| 1170 | int GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 2; | 1266 | int BOUNDED_SCOPE_DEFINITION__UPPER_BOUND = SCOPE_DEFINITION_FEATURE_COUNT + 1; |
| 1171 | 1267 | ||
| 1172 | /** | 1268 | /** |
| 1173 | * The feature id for the '<em><b>Source</b></em>' containment reference. | 1269 | * The number of structural features of the '<em>Bounded Scope Definition</em>' class. |
| 1174 | * <!-- begin-user-doc --> | 1270 | * <!-- begin-user-doc --> |
| 1175 | * <!-- end-user-doc --> | 1271 | * <!-- end-user-doc --> |
| 1176 | * @generated | 1272 | * @generated |
| 1177 | * @ordered | 1273 | * @ordered |
| 1178 | */ | 1274 | */ |
| 1179 | int GLOBAL_RELATION_INTERPRETATION__SOURCE = CD_INTERPRETATION_FEATURE_COUNT + 3; | 1275 | int BOUNDED_SCOPE_DEFINITION_FEATURE_COUNT = SCOPE_DEFINITION_FEATURE_COUNT + 2; |
| 1276 | |||
| 1277 | /** | ||
| 1278 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LowerBoundedScopeDefinitionImpl <em>Lower Bounded Scope Definition</em>}' class. | ||
| 1279 | * <!-- begin-user-doc --> | ||
| 1280 | * <!-- end-user-doc --> | ||
| 1281 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LowerBoundedScopeDefinitionImpl | ||
| 1282 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLowerBoundedScopeDefinition() | ||
| 1283 | * @generated | ||
| 1284 | */ | ||
| 1285 | int LOWER_BOUNDED_SCOPE_DEFINITION = 37; | ||
| 1180 | 1286 | ||
| 1181 | /** | 1287 | /** |
| 1182 | * The feature id for the '<em><b>Target Multiplicity</b></em>' containment reference. | 1288 | * The feature id for the '<em><b>Type</b></em>' reference. |
| 1183 | * <!-- begin-user-doc --> | 1289 | * <!-- begin-user-doc --> |
| 1184 | * <!-- end-user-doc --> | 1290 | * <!-- end-user-doc --> |
| 1185 | * @generated | 1291 | * @generated |
| 1186 | * @ordered | 1292 | * @ordered |
| 1187 | */ | 1293 | */ |
| 1188 | int GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 4; | 1294 | int LOWER_BOUNDED_SCOPE_DEFINITION__TYPE = SCOPE_DEFINITION__TYPE; |
| 1189 | 1295 | ||
| 1190 | /** | 1296 | /** |
| 1191 | * The feature id for the '<em><b>Target</b></em>' containment reference. | 1297 | * The feature id for the '<em><b>Lower Bound</b></em>' attribute. |
| 1192 | * <!-- begin-user-doc --> | 1298 | * <!-- begin-user-doc --> |
| 1193 | * <!-- end-user-doc --> | 1299 | * <!-- end-user-doc --> |
| 1194 | * @generated | 1300 | * @generated |
| 1195 | * @ordered | 1301 | * @ordered |
| 1196 | */ | 1302 | */ |
| 1197 | int GLOBAL_RELATION_INTERPRETATION__TARGET = CD_INTERPRETATION_FEATURE_COUNT + 5; | 1303 | int LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND = SCOPE_DEFINITION_FEATURE_COUNT + 0; |
| 1304 | |||
| 1305 | /** | ||
| 1306 | * The number of structural features of the '<em>Lower Bounded Scope Definition</em>' class. | ||
| 1307 | * <!-- begin-user-doc --> | ||
| 1308 | * <!-- end-user-doc --> | ||
| 1309 | * @generated | ||
| 1310 | * @ordered | ||
| 1311 | */ | ||
| 1312 | int LOWER_BOUNDED_SCOPE_DEFINITION_FEATURE_COUNT = SCOPE_DEFINITION_FEATURE_COUNT + 1; | ||
| 1313 | |||
| 1314 | /** | ||
| 1315 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl <em>Objective Definition</em>}' class. | ||
| 1316 | * <!-- begin-user-doc --> | ||
| 1317 | * <!-- end-user-doc --> | ||
| 1318 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl | ||
| 1319 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObjectiveDefinition() | ||
| 1320 | * @generated | ||
| 1321 | */ | ||
| 1322 | int OBJECTIVE_DEFINITION = 38; | ||
| 1198 | 1323 | ||
| 1199 | /** | 1324 | /** |
| 1200 | * The number of structural features of the '<em>Global Relation Interpretation</em>' class. | 1325 | * The feature id for the '<em><b>Kind</b></em>' attribute. |
| 1201 | * <!-- begin-user-doc --> | 1326 | * <!-- begin-user-doc --> |
| 1202 | * <!-- end-user-doc --> | 1327 | * <!-- end-user-doc --> |
| 1203 | * @generated | 1328 | * @generated |
| 1204 | * @ordered | 1329 | * @ordered |
| 1205 | */ | 1330 | */ |
| 1206 | int GLOBAL_RELATION_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 6; | 1331 | int OBJECTIVE_DEFINITION__KIND = STATEMENT_FEATURE_COUNT + 0; |
| 1207 | 1332 | ||
| 1208 | /** | 1333 | /** |
| 1209 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl <em>Multiplicity Definition</em>}' class. | 1334 | * The feature id for the '<em><b>Objective</b></em>' containment reference. |
| 1210 | * <!-- begin-user-doc --> | 1335 | * <!-- begin-user-doc --> |
| 1211 | * <!-- end-user-doc --> | 1336 | * <!-- end-user-doc --> |
| 1212 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl | ||
| 1213 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition() | ||
| 1214 | * @generated | 1337 | * @generated |
| 1338 | * @ordered | ||
| 1215 | */ | 1339 | */ |
| 1216 | int MULTIPLICITY_DEFINITION = 41; | 1340 | int OBJECTIVE_DEFINITION__OBJECTIVE = STATEMENT_FEATURE_COUNT + 1; |
| 1217 | 1341 | ||
| 1218 | /** | 1342 | /** |
| 1219 | * The feature id for the '<em><b>Lower</b></em>' attribute. | 1343 | * The number of structural features of the '<em>Objective Definition</em>' class. |
| 1220 | * <!-- begin-user-doc --> | 1344 | * <!-- begin-user-doc --> |
| 1221 | * <!-- end-user-doc --> | 1345 | * <!-- end-user-doc --> |
| 1222 | * @generated | 1346 | * @generated |
| 1223 | * @ordered | 1347 | * @ordered |
| 1224 | */ | 1348 | */ |
| 1225 | int MULTIPLICITY_DEFINITION__LOWER = 0; | 1349 | int OBJECTIVE_DEFINITION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; |
| 1350 | |||
| 1351 | /** | ||
| 1352 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedElementImpl <em>Named Element</em>}' class. | ||
| 1353 | * <!-- begin-user-doc --> | ||
| 1354 | * <!-- end-user-doc --> | ||
| 1355 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedElementImpl | ||
| 1356 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedElement() | ||
| 1357 | * @generated | ||
| 1358 | */ | ||
| 1359 | int NAMED_ELEMENT = 39; | ||
| 1226 | 1360 | ||
| 1227 | /** | 1361 | /** |
| 1228 | * The feature id for the '<em><b>Upper</b></em>' attribute. | 1362 | * The feature id for the '<em><b>Name</b></em>' attribute. |
| 1229 | * <!-- begin-user-doc --> | 1363 | * <!-- begin-user-doc --> |
| 1230 | * <!-- end-user-doc --> | 1364 | * <!-- end-user-doc --> |
| 1231 | * @generated | 1365 | * @generated |
| 1232 | * @ordered | 1366 | * @ordered |
| 1233 | */ | 1367 | */ |
| 1234 | int MULTIPLICITY_DEFINITION__UPPER = 1; | 1368 | int NAMED_ELEMENT__NAME = 0; |
| 1235 | 1369 | ||
| 1236 | /** | 1370 | /** |
| 1237 | * The feature id for the '<em><b>Unlimited Upper</b></em>' attribute. | 1371 | * The number of structural features of the '<em>Named Element</em>' class. |
| 1238 | * <!-- begin-user-doc --> | 1372 | * <!-- begin-user-doc --> |
| 1239 | * <!-- end-user-doc --> | 1373 | * <!-- end-user-doc --> |
| 1240 | * @generated | 1374 | * @generated |
| 1241 | * @ordered | 1375 | * @ordered |
| 1242 | */ | 1376 | */ |
| 1243 | int MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = 2; | 1377 | int NAMED_ELEMENT_FEATURE_COUNT = 1; |
| 1244 | 1378 | ||
| 1245 | /** | 1379 | /** |
| 1246 | * The number of structural features of the '<em>Multiplicity Definition</em>' class. | 1380 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl <em>Assertion</em>}' class. |
| 1381 | * <!-- begin-user-doc --> | ||
| 1382 | * <!-- end-user-doc --> | ||
| 1383 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl | ||
| 1384 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAssertion() | ||
| 1385 | * @generated | ||
| 1386 | */ | ||
| 1387 | int ASSERTION = 40; | ||
| 1388 | |||
| 1389 | /** | ||
| 1390 | * The feature id for the '<em><b>Body</b></em>' containment reference. | ||
| 1247 | * <!-- begin-user-doc --> | 1391 | * <!-- begin-user-doc --> |
| 1248 | * <!-- end-user-doc --> | 1392 | * <!-- end-user-doc --> |
| 1249 | * @generated | 1393 | * @generated |
| 1250 | * @ordered | 1394 | * @ordered |
| 1251 | */ | 1395 | */ |
| 1252 | int MULTIPLICITY_DEFINITION_FEATURE_COUNT = 3; | 1396 | int ASSERTION__BODY = STATEMENT_FEATURE_COUNT + 0; |
| 1253 | 1397 | ||
| 1254 | /** | 1398 | /** |
| 1255 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl <em>Boolean True</em>}' class. | 1399 | * The feature id for the '<em><b>Range</b></em>' containment reference. |
| 1256 | * <!-- begin-user-doc --> | 1400 | * <!-- begin-user-doc --> |
| 1257 | * <!-- end-user-doc --> | 1401 | * <!-- end-user-doc --> |
| 1258 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl | ||
| 1259 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue() | ||
| 1260 | * @generated | 1402 | * @generated |
| 1403 | * @ordered | ||
| 1261 | */ | 1404 | */ |
| 1262 | int BOOLEAN_TRUE = 42; | 1405 | int ASSERTION__RANGE = STATEMENT_FEATURE_COUNT + 1; |
| 1263 | 1406 | ||
| 1264 | /** | 1407 | /** |
| 1265 | * The number of structural features of the '<em>Boolean True</em>' class. | 1408 | * The number of structural features of the '<em>Assertion</em>' class. |
| 1266 | * <!-- begin-user-doc --> | 1409 | * <!-- begin-user-doc --> |
| 1267 | * <!-- end-user-doc --> | 1410 | * <!-- end-user-doc --> |
| 1268 | * @generated | 1411 | * @generated |
| 1269 | * @ordered | 1412 | * @ordered |
| 1270 | */ | 1413 | */ |
| 1271 | int BOOLEAN_TRUE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0; | 1414 | int ASSERTION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; |
| 1415 | |||
| 1416 | /** | ||
| 1417 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DisjunctionImpl <em>Disjunction</em>}' class. | ||
| 1418 | * <!-- begin-user-doc --> | ||
| 1419 | * <!-- end-user-doc --> | ||
| 1420 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DisjunctionImpl | ||
| 1421 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDisjunction() | ||
| 1422 | * @generated | ||
| 1423 | */ | ||
| 1424 | int DISJUNCTION = 41; | ||
| 1272 | 1425 | ||
| 1273 | /** | 1426 | /** |
| 1274 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl <em>Boolean False</em>}' class. | 1427 | * The feature id for the '<em><b>Children</b></em>' containment reference list. |
| 1275 | * <!-- begin-user-doc --> | 1428 | * <!-- begin-user-doc --> |
| 1276 | * <!-- end-user-doc --> | 1429 | * <!-- end-user-doc --> |
| 1277 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl | ||
| 1278 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse() | ||
| 1279 | * @generated | 1430 | * @generated |
| 1431 | * @ordered | ||
| 1280 | */ | 1432 | */ |
| 1281 | int BOOLEAN_FALSE = 43; | 1433 | int DISJUNCTION__CHILDREN = EXPRESSION_FEATURE_COUNT + 0; |
| 1282 | 1434 | ||
| 1283 | /** | 1435 | /** |
| 1284 | * The number of structural features of the '<em>Boolean False</em>' class. | 1436 | * The number of structural features of the '<em>Disjunction</em>' class. |
| 1285 | * <!-- begin-user-doc --> | 1437 | * <!-- begin-user-doc --> |
| 1286 | * <!-- end-user-doc --> | 1438 | * <!-- end-user-doc --> |
| 1287 | * @generated | 1439 | * @generated |
| 1288 | * @ordered | 1440 | * @ordered |
| 1289 | */ | 1441 | */ |
| 1290 | int BOOLEAN_FALSE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0; | 1442 | int DISJUNCTION_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 1; |
| 1291 | 1443 | ||
| 1292 | /** | 1444 | /** |
| 1293 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl <em>True</em>}' class. | 1445 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SwitchImpl <em>Switch</em>}' class. |
| 1294 | * <!-- begin-user-doc --> | 1446 | * <!-- begin-user-doc --> |
| 1295 | * <!-- end-user-doc --> | 1447 | * <!-- end-user-doc --> |
| 1296 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl | 1448 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SwitchImpl |
| 1297 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue() | 1449 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSwitch() |
| 1298 | * @generated | 1450 | * @generated |
| 1299 | */ | 1451 | */ |
| 1300 | int TRUE = 44; | 1452 | int SWITCH = 42; |
| 1301 | 1453 | ||
| 1302 | /** | 1454 | /** |
| 1303 | * The number of structural features of the '<em>True</em>' class. | 1455 | * The feature id for the '<em><b>Cases</b></em>' containment reference list. |
| 1304 | * <!-- begin-user-doc --> | 1456 | * <!-- begin-user-doc --> |
| 1305 | * <!-- end-user-doc --> | 1457 | * <!-- end-user-doc --> |
| 1306 | * @generated | 1458 | * @generated |
| 1307 | * @ordered | 1459 | * @ordered |
| 1308 | */ | 1460 | */ |
| 1309 | int TRUE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; | 1461 | int SWITCH__CASES = EXPRESSION_FEATURE_COUNT + 0; |
| 1310 | 1462 | ||
| 1311 | /** | 1463 | /** |
| 1312 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl <em>False</em>}' class. | 1464 | * The number of structural features of the '<em>Switch</em>' class. |
| 1313 | * <!-- begin-user-doc --> | 1465 | * <!-- begin-user-doc --> |
| 1314 | * <!-- end-user-doc --> | 1466 | * <!-- end-user-doc --> |
| 1315 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl | ||
| 1316 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse() | ||
| 1317 | * @generated | 1467 | * @generated |
| 1468 | * @ordered | ||
| 1469 | */ | ||
| 1470 | int SWITCH_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 1; | ||
| 1471 | |||
| 1472 | /** | ||
| 1473 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConjunctionImpl <em>Conjunction</em>}' class. | ||
| 1474 | * <!-- begin-user-doc --> | ||
| 1475 | * <!-- end-user-doc --> | ||
| 1476 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConjunctionImpl | ||
| 1477 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConjunction() | ||
| 1478 | * @generated | ||
| 1479 | */ | ||
| 1480 | int CONJUNCTION = 43; | ||
| 1481 | |||
| 1482 | /** | ||
| 1483 | * The feature id for the '<em><b>Children</b></em>' containment reference list. | ||
| 1484 | * <!-- begin-user-doc --> | ||
| 1485 | * <!-- end-user-doc --> | ||
| 1486 | * @generated | ||
| 1487 | * @ordered | ||
| 1318 | */ | 1488 | */ |
| 1319 | int FALSE = 45; | 1489 | int CONJUNCTION__CHILDREN = EXPRESSION_FEATURE_COUNT + 0; |
| 1320 | 1490 | ||
| 1321 | /** | 1491 | /** |
| 1322 | * The number of structural features of the '<em>False</em>' class. | 1492 | * The number of structural features of the '<em>Conjunction</em>' class. |
| 1323 | * <!-- begin-user-doc --> | 1493 | * <!-- begin-user-doc --> |
| 1324 | * <!-- end-user-doc --> | 1494 | * <!-- end-user-doc --> |
| 1325 | * @generated | 1495 | * @generated |
| 1326 | * @ordered | 1496 | * @ordered |
| 1327 | */ | 1497 | */ |
| 1328 | int FALSE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; | 1498 | int CONJUNCTION_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 1; |
| 1329 | 1499 | ||
| 1330 | /** | 1500 | /** |
| 1331 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl <em>Unknown</em>}' class. | 1501 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl <em>Comparison</em>}' class. |
| 1332 | * <!-- begin-user-doc --> | 1502 | * <!-- begin-user-doc --> |
| 1333 | * <!-- end-user-doc --> | 1503 | * <!-- end-user-doc --> |
| 1334 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl | 1504 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl |
| 1335 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown() | 1505 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComparison() |
| 1336 | * @generated | 1506 | * @generated |
| 1337 | */ | 1507 | */ |
| 1338 | int UNKNOWN = 46; | 1508 | int COMPARISON = 44; |
| 1339 | 1509 | ||
| 1340 | /** | 1510 | /** |
| 1341 | * The number of structural features of the '<em>Unknown</em>' class. | 1511 | * The feature id for the '<em><b>Left</b></em>' containment reference. |
| 1342 | * <!-- begin-user-doc --> | 1512 | * <!-- begin-user-doc --> |
| 1343 | * <!-- end-user-doc --> | 1513 | * <!-- end-user-doc --> |
| 1344 | * @generated | 1514 | * @generated |
| 1345 | * @ordered | 1515 | * @ordered |
| 1346 | */ | 1516 | */ |
| 1347 | int UNKNOWN_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; | 1517 | int COMPARISON__LEFT = EXPRESSION_FEATURE_COUNT + 0; |
| 1348 | 1518 | ||
| 1349 | /** | 1519 | /** |
| 1350 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl <em>Error</em>}' class. | 1520 | * The feature id for the '<em><b>Op</b></em>' attribute. |
| 1351 | * <!-- begin-user-doc --> | 1521 | * <!-- begin-user-doc --> |
| 1352 | * <!-- end-user-doc --> | 1522 | * <!-- end-user-doc --> |
| 1353 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl | ||
| 1354 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError() | ||
| 1355 | * @generated | 1523 | * @generated |
| 1524 | * @ordered | ||
| 1525 | */ | ||
| 1526 | int COMPARISON__OP = EXPRESSION_FEATURE_COUNT + 1; | ||
| 1527 | |||
| 1528 | /** | ||
| 1529 | * The feature id for the '<em><b>Right</b></em>' containment reference. | ||
| 1530 | * <!-- begin-user-doc --> | ||
| 1531 | * <!-- end-user-doc --> | ||
| 1532 | * @generated | ||
| 1533 | * @ordered | ||
| 1356 | */ | 1534 | */ |
| 1357 | int ERROR = 47; | 1535 | int COMPARISON__RIGHT = EXPRESSION_FEATURE_COUNT + 2; |
| 1358 | 1536 | ||
| 1359 | /** | 1537 | /** |
| 1360 | * The number of structural features of the '<em>Error</em>' class. | 1538 | * The number of structural features of the '<em>Comparison</em>' class. |
| 1361 | * <!-- begin-user-doc --> | 1539 | * <!-- begin-user-doc --> |
| 1362 | * <!-- end-user-doc --> | 1540 | * <!-- end-user-doc --> |
| 1363 | * @generated | 1541 | * @generated |
| 1364 | * @ordered | 1542 | * @ordered |
| 1365 | */ | 1543 | */ |
| 1366 | int ERROR_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; | 1544 | int COMPARISON_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 3; |
| 1367 | 1545 | ||
| 1368 | /** | 1546 | /** |
| 1369 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl <em>Positive</em>}' class. | 1547 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl <em>Binary Expression</em>}' class. |
| 1370 | * <!-- begin-user-doc --> | 1548 | * <!-- begin-user-doc --> |
| 1371 | * <!-- end-user-doc --> | 1549 | * <!-- end-user-doc --> |
| 1372 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl | 1550 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl |
| 1373 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive() | 1551 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBinaryExpression() |
| 1374 | * @generated | 1552 | * @generated |
| 1375 | */ | 1553 | */ |
| 1376 | int POSITIVE = 48; | 1554 | int BINARY_EXPRESSION = 45; |
| 1377 | 1555 | ||
| 1378 | /** | 1556 | /** |
| 1379 | * The number of structural features of the '<em>Positive</em>' class. | 1557 | * The feature id for the '<em><b>Left</b></em>' containment reference. |
| 1380 | * <!-- begin-user-doc --> | 1558 | * <!-- begin-user-doc --> |
| 1381 | * <!-- end-user-doc --> | 1559 | * <!-- end-user-doc --> |
| 1382 | * @generated | 1560 | * @generated |
| 1383 | * @ordered | 1561 | * @ordered |
| 1384 | */ | 1562 | */ |
| 1385 | int POSITIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0; | 1563 | int BINARY_EXPRESSION__LEFT = EXPRESSION_FEATURE_COUNT + 0; |
| 1386 | 1564 | ||
| 1387 | /** | 1565 | /** |
| 1388 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl <em>Negative</em>}' class. | 1566 | * The feature id for the '<em><b>Op</b></em>' attribute. |
| 1389 | * <!-- begin-user-doc --> | 1567 | * <!-- begin-user-doc --> |
| 1390 | * <!-- end-user-doc --> | 1568 | * <!-- end-user-doc --> |
| 1391 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl | ||
| 1392 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative() | ||
| 1393 | * @generated | 1569 | * @generated |
| 1570 | * @ordered | ||
| 1394 | */ | 1571 | */ |
| 1395 | int NEGATIVE = 49; | 1572 | int BINARY_EXPRESSION__OP = EXPRESSION_FEATURE_COUNT + 1; |
| 1396 | 1573 | ||
| 1397 | /** | 1574 | /** |
| 1398 | * The number of structural features of the '<em>Negative</em>' class. | 1575 | * The feature id for the '<em><b>Right</b></em>' containment reference. |
| 1399 | * <!-- begin-user-doc --> | 1576 | * <!-- begin-user-doc --> |
| 1400 | * <!-- end-user-doc --> | 1577 | * <!-- end-user-doc --> |
| 1401 | * @generated | 1578 | * @generated |
| 1402 | * @ordered | 1579 | * @ordered |
| 1403 | */ | 1580 | */ |
| 1404 | int NEGATIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0; | 1581 | int BINARY_EXPRESSION__RIGHT = EXPRESSION_FEATURE_COUNT + 2; |
| 1405 | 1582 | ||
| 1406 | /** | 1583 | /** |
| 1407 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl <em>Reflexive Closure</em>}' class. | 1584 | * The number of structural features of the '<em>Binary Expression</em>' class. |
| 1408 | * <!-- begin-user-doc --> | 1585 | * <!-- begin-user-doc --> |
| 1409 | * <!-- end-user-doc --> | 1586 | * <!-- end-user-doc --> |
| 1410 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl | ||
| 1411 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure() | ||
| 1412 | * @generated | 1587 | * @generated |
| 1588 | * @ordered | ||
| 1413 | */ | 1589 | */ |
| 1414 | int REFLEXIVE_CLOSURE = 50; | 1590 | int BINARY_EXPRESSION_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 3; |
| 1415 | 1591 | ||
| 1416 | /** | 1592 | /** |
| 1417 | * The number of structural features of the '<em>Reflexive Closure</em>' class. | 1593 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl <em>Unary Expression</em>}' class. |
| 1594 | * <!-- begin-user-doc --> | ||
| 1595 | * <!-- end-user-doc --> | ||
| 1596 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl | ||
| 1597 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnaryExpression() | ||
| 1598 | * @generated | ||
| 1599 | */ | ||
| 1600 | int UNARY_EXPRESSION = 46; | ||
| 1601 | |||
| 1602 | /** | ||
| 1603 | * The feature id for the '<em><b>Op</b></em>' attribute. | ||
| 1418 | * <!-- begin-user-doc --> | 1604 | * <!-- begin-user-doc --> |
| 1419 | * <!-- end-user-doc --> | 1605 | * <!-- end-user-doc --> |
| 1420 | * @generated | 1606 | * @generated |
| 1421 | * @ordered | 1607 | * @ordered |
| 1422 | */ | 1608 | */ |
| 1423 | int REFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0; | 1609 | int UNARY_EXPRESSION__OP = EXPRESSION_FEATURE_COUNT + 0; |
| 1424 | 1610 | ||
| 1425 | /** | 1611 | /** |
| 1426 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl <em>Irreflexive Closure</em>}' class. | 1612 | * The feature id for the '<em><b>Body</b></em>' containment reference. |
| 1427 | * <!-- begin-user-doc --> | 1613 | * <!-- begin-user-doc --> |
| 1428 | * <!-- end-user-doc --> | 1614 | * <!-- end-user-doc --> |
| 1429 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl | ||
| 1430 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure() | ||
| 1431 | * @generated | 1615 | * @generated |
| 1616 | * @ordered | ||
| 1432 | */ | 1617 | */ |
| 1433 | int IRREFLEXIVE_CLOSURE = 51; | 1618 | int UNARY_EXPRESSION__BODY = EXPRESSION_FEATURE_COUNT + 1; |
| 1434 | 1619 | ||
| 1435 | /** | 1620 | /** |
| 1436 | * The number of structural features of the '<em>Irreflexive Closure</em>' class. | 1621 | * The number of structural features of the '<em>Unary Expression</em>' class. |
| 1437 | * <!-- begin-user-doc --> | 1622 | * <!-- begin-user-doc --> |
| 1438 | * <!-- end-user-doc --> | 1623 | * <!-- end-user-doc --> |
| 1439 | * @generated | 1624 | * @generated |
| 1440 | * @ordered | 1625 | * @ordered |
| 1441 | */ | 1626 | */ |
| 1442 | int IRREFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0; | 1627 | int UNARY_EXPRESSION_FEATURE_COUNT = EXPRESSION_FEATURE_COUNT + 2; |
| 1628 | |||
| 1629 | /** | ||
| 1630 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricType <em>Metric Type</em>}' enum. | ||
| 1631 | * <!-- begin-user-doc --> | ||
| 1632 | * <!-- end-user-doc --> | ||
| 1633 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 1634 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMetricType() | ||
| 1635 | * @generated | ||
| 1636 | */ | ||
| 1637 | int METRIC_TYPE = 47; | ||
| 1638 | |||
| 1639 | /** | ||
| 1640 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator <em>Binary Operator</em>}' enum. | ||
| 1641 | * <!-- begin-user-doc --> | ||
| 1642 | * <!-- end-user-doc --> | ||
| 1643 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 1644 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBinaryOperator() | ||
| 1645 | * @generated | ||
| 1646 | */ | ||
| 1647 | int BINARY_OPERATOR = 48; | ||
| 1648 | |||
| 1649 | /** | ||
| 1650 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryOp <em>Unary Op</em>}' enum. | ||
| 1651 | * <!-- begin-user-doc --> | ||
| 1652 | * <!-- end-user-doc --> | ||
| 1653 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryOp | ||
| 1654 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnaryOp() | ||
| 1655 | * @generated | ||
| 1656 | */ | ||
| 1657 | int UNARY_OP = 49; | ||
| 1658 | |||
| 1659 | /** | ||
| 1660 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.AggregationOp <em>Aggregation Op</em>}' enum. | ||
| 1661 | * <!-- begin-user-doc --> | ||
| 1662 | * <!-- end-user-doc --> | ||
| 1663 | * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOp | ||
| 1664 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAggregationOp() | ||
| 1665 | * @generated | ||
| 1666 | */ | ||
| 1667 | int AGGREGATION_OP = 50; | ||
| 1668 | |||
| 1669 | /** | ||
| 1670 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicValue <em>Logic Value</em>}' enum. | ||
| 1671 | * <!-- begin-user-doc --> | ||
| 1672 | * <!-- end-user-doc --> | ||
| 1673 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicValue | ||
| 1674 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLogicValue() | ||
| 1675 | * @generated | ||
| 1676 | */ | ||
| 1677 | int LOGIC_VALUE = 51; | ||
| 1678 | |||
| 1679 | /** | ||
| 1680 | * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind <em>Objective Kind</em>}' enum. | ||
| 1681 | * <!-- begin-user-doc --> | ||
| 1682 | * <!-- end-user-doc --> | ||
| 1683 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind | ||
| 1684 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObjectiveKind() | ||
| 1685 | * @generated | ||
| 1686 | */ | ||
| 1687 | int OBJECTIVE_KIND = 52; | ||
| 1443 | 1688 | ||
| 1444 | 1689 | ||
| 1445 | /** | 1690 | /** |
| @@ -1474,525 +1719,589 @@ public interface SolverLanguagePackage extends EPackage | |||
| 1474 | EClass getStatement(); | 1719 | EClass getStatement(); |
| 1475 | 1720 | ||
| 1476 | /** | 1721 | /** |
| 1477 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue <em>Boolean Value</em>}'. | 1722 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition <em>Predicate Definition</em>}'. |
| 1478 | * <!-- begin-user-doc --> | 1723 | * <!-- begin-user-doc --> |
| 1479 | * <!-- end-user-doc --> | 1724 | * <!-- end-user-doc --> |
| 1480 | * @return the meta object for class '<em>Boolean Value</em>'. | 1725 | * @return the meta object for class '<em>Predicate Definition</em>'. |
| 1481 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue | 1726 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition |
| 1482 | * @generated | 1727 | * @generated |
| 1483 | */ | 1728 | */ |
| 1484 | EClass getBooleanValue(); | 1729 | EClass getPredicateDefinition(); |
| 1485 | 1730 | ||
| 1486 | /** | 1731 | /** |
| 1487 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue <em>Truth Value</em>}'. | 1732 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getHead <em>Head</em>}'. |
| 1488 | * <!-- begin-user-doc --> | 1733 | * <!-- begin-user-doc --> |
| 1489 | * <!-- end-user-doc --> | 1734 | * <!-- end-user-doc --> |
| 1490 | * @return the meta object for class '<em>Truth Value</em>'. | 1735 | * @return the meta object for the containment reference '<em>Head</em>'. |
| 1491 | * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue | 1736 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getHead() |
| 1737 | * @see #getPredicateDefinition() | ||
| 1492 | * @generated | 1738 | * @generated |
| 1493 | */ | 1739 | */ |
| 1494 | EClass getTruthValue(); | 1740 | EReference getPredicateDefinition_Head(); |
| 1495 | 1741 | ||
| 1496 | /** | 1742 | /** |
| 1497 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation <em>Interpretation</em>}'. | 1743 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getBody <em>Body</em>}'. |
| 1498 | * <!-- begin-user-doc --> | 1744 | * <!-- begin-user-doc --> |
| 1499 | * <!-- end-user-doc --> | 1745 | * <!-- end-user-doc --> |
| 1500 | * @return the meta object for class '<em>Interpretation</em>'. | 1746 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1501 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation | 1747 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#getBody() |
| 1748 | * @see #getPredicateDefinition() | ||
| 1502 | * @generated | 1749 | * @generated |
| 1503 | */ | 1750 | */ |
| 1504 | EClass getInterpretation(); | 1751 | EReference getPredicateDefinition_Body(); |
| 1505 | 1752 | ||
| 1506 | /** | 1753 | /** |
| 1507 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation <em>Basic Interpretation</em>}'. | 1754 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isFunctional <em>Functional</em>}'. |
| 1508 | * <!-- begin-user-doc --> | 1755 | * <!-- begin-user-doc --> |
| 1509 | * <!-- end-user-doc --> | 1756 | * <!-- end-user-doc --> |
| 1510 | * @return the meta object for class '<em>Basic Interpretation</em>'. | 1757 | * @return the meta object for the attribute '<em>Functional</em>'. |
| 1511 | * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation | 1758 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isFunctional() |
| 1759 | * @see #getPredicateDefinition() | ||
| 1512 | * @generated | 1760 | * @generated |
| 1513 | */ | 1761 | */ |
| 1514 | EClass getBasicInterpretation(); | 1762 | EAttribute getPredicateDefinition_Functional(); |
| 1515 | 1763 | ||
| 1516 | /** | 1764 | /** |
| 1517 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}'. | 1765 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isError <em>Error</em>}'. |
| 1518 | * <!-- begin-user-doc --> | 1766 | * <!-- begin-user-doc --> |
| 1519 | * <!-- end-user-doc --> | 1767 | * <!-- end-user-doc --> |
| 1520 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 1768 | * @return the meta object for the attribute '<em>Error</em>'. |
| 1521 | * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol() | 1769 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition#isError() |
| 1522 | * @see #getBasicInterpretation() | 1770 | * @see #getPredicateDefinition() |
| 1523 | * @generated | 1771 | * @generated |
| 1524 | */ | 1772 | */ |
| 1525 | EReference getBasicInterpretation_Symbol(); | 1773 | EAttribute getPredicateDefinition_Error(); |
| 1526 | 1774 | ||
| 1527 | /** | 1775 | /** |
| 1528 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects <em>Objects</em>}'. | 1776 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition <em>Unnamed Error Prediate Definition</em>}'. |
| 1529 | * <!-- begin-user-doc --> | 1777 | * <!-- begin-user-doc --> |
| 1530 | * <!-- end-user-doc --> | 1778 | * <!-- end-user-doc --> |
| 1531 | * @return the meta object for the containment reference list '<em>Objects</em>'. | 1779 | * @return the meta object for class '<em>Unnamed Error Prediate Definition</em>'. |
| 1532 | * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects() | 1780 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition |
| 1533 | * @see #getBasicInterpretation() | ||
| 1534 | * @generated | 1781 | * @generated |
| 1535 | */ | 1782 | */ |
| 1536 | EReference getBasicInterpretation_Objects(); | 1783 | EClass getUnnamedErrorPrediateDefinition(); |
| 1537 | 1784 | ||
| 1538 | /** | 1785 | /** |
| 1539 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}'. | 1786 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getArgumentList <em>Argument List</em>}'. |
| 1540 | * <!-- begin-user-doc --> | 1787 | * <!-- begin-user-doc --> |
| 1541 | * <!-- end-user-doc --> | 1788 | * <!-- end-user-doc --> |
| 1542 | * @return the meta object for the containment reference '<em>Value</em>'. | 1789 | * @return the meta object for the containment reference '<em>Argument List</em>'. |
| 1543 | * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue() | 1790 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getArgumentList() |
| 1544 | * @see #getBasicInterpretation() | 1791 | * @see #getUnnamedErrorPrediateDefinition() |
| 1545 | * @generated | 1792 | * @generated |
| 1546 | */ | 1793 | */ |
| 1547 | EReference getBasicInterpretation_Value(); | 1794 | EReference getUnnamedErrorPrediateDefinition_ArgumentList(); |
| 1548 | 1795 | ||
| 1549 | /** | 1796 | /** |
| 1550 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol <em>Symbol</em>}'. | 1797 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getBody <em>Body</em>}'. |
| 1551 | * <!-- begin-user-doc --> | 1798 | * <!-- begin-user-doc --> |
| 1552 | * <!-- end-user-doc --> | 1799 | * <!-- end-user-doc --> |
| 1553 | * @return the meta object for class '<em>Symbol</em>'. | 1800 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1554 | * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol | 1801 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getBody() |
| 1802 | * @see #getUnnamedErrorPrediateDefinition() | ||
| 1555 | * @generated | 1803 | * @generated |
| 1556 | */ | 1804 | */ |
| 1557 | EClass getSymbol(); | 1805 | EReference getUnnamedErrorPrediateDefinition_Body(); |
| 1558 | 1806 | ||
| 1559 | /** | 1807 | /** |
| 1560 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol <em>Model Symbol</em>}'. | 1808 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition <em>Default Definition</em>}'. |
| 1561 | * <!-- begin-user-doc --> | 1809 | * <!-- begin-user-doc --> |
| 1562 | * <!-- end-user-doc --> | 1810 | * <!-- end-user-doc --> |
| 1563 | * @return the meta object for class '<em>Model Symbol</em>'. | 1811 | * @return the meta object for class '<em>Default Definition</em>'. |
| 1564 | * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol | 1812 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition |
| 1565 | * @generated | 1813 | * @generated |
| 1566 | */ | 1814 | */ |
| 1567 | EClass getModelSymbol(); | 1815 | EClass getDefaultDefinition(); |
| 1568 | 1816 | ||
| 1569 | /** | 1817 | /** |
| 1570 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}'. | 1818 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getHead <em>Head</em>}'. |
| 1571 | * <!-- begin-user-doc --> | 1819 | * <!-- begin-user-doc --> |
| 1572 | * <!-- end-user-doc --> | 1820 | * <!-- end-user-doc --> |
| 1573 | * @return the meta object for the attribute '<em>Name</em>'. | 1821 | * @return the meta object for the containment reference '<em>Head</em>'. |
| 1574 | * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName() | 1822 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getHead() |
| 1575 | * @see #getModelSymbol() | 1823 | * @see #getDefaultDefinition() |
| 1576 | * @generated | 1824 | * @generated |
| 1577 | */ | 1825 | */ |
| 1578 | EAttribute getModelSymbol_Name(); | 1826 | EReference getDefaultDefinition_Head(); |
| 1579 | 1827 | ||
| 1580 | /** | 1828 | /** |
| 1581 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol <em>Partiality Symbol</em>}'. | 1829 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getRange <em>Range</em>}'. |
| 1582 | * <!-- begin-user-doc --> | 1830 | * <!-- begin-user-doc --> |
| 1583 | * <!-- end-user-doc --> | 1831 | * <!-- end-user-doc --> |
| 1584 | * @return the meta object for class '<em>Partiality Symbol</em>'. | 1832 | * @return the meta object for the containment reference '<em>Range</em>'. |
| 1585 | * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol | 1833 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition#getRange() |
| 1834 | * @see #getDefaultDefinition() | ||
| 1586 | * @generated | 1835 | * @generated |
| 1587 | */ | 1836 | */ |
| 1588 | EClass getPartialitySymbol(); | 1837 | EReference getDefaultDefinition_Range(); |
| 1589 | 1838 | ||
| 1590 | /** | 1839 | /** |
| 1591 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol <em>Exist Symbol</em>}'. | 1840 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition <em>Extern Predicate Definition</em>}'. |
| 1592 | * <!-- begin-user-doc --> | 1841 | * <!-- begin-user-doc --> |
| 1593 | * <!-- end-user-doc --> | 1842 | * <!-- end-user-doc --> |
| 1594 | * @return the meta object for class '<em>Exist Symbol</em>'. | 1843 | * @return the meta object for class '<em>Extern Predicate Definition</em>'. |
| 1595 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol | 1844 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition |
| 1596 | * @generated | 1845 | * @generated |
| 1597 | */ | 1846 | */ |
| 1598 | EClass getExistSymbol(); | 1847 | EClass getExternPredicateDefinition(); |
| 1599 | 1848 | ||
| 1600 | /** | 1849 | /** |
| 1601 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol <em>Equals Symbol</em>}'. | 1850 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition#getHead <em>Head</em>}'. |
| 1602 | * <!-- begin-user-doc --> | 1851 | * <!-- begin-user-doc --> |
| 1603 | * <!-- end-user-doc --> | 1852 | * <!-- end-user-doc --> |
| 1604 | * @return the meta object for class '<em>Equals Symbol</em>'. | 1853 | * @return the meta object for the containment reference '<em>Head</em>'. |
| 1605 | * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol | 1854 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition#getHead() |
| 1855 | * @see #getExternPredicateDefinition() | ||
| 1606 | * @generated | 1856 | * @generated |
| 1607 | */ | 1857 | */ |
| 1608 | EClass getEqualsSymbol(); | 1858 | EReference getExternPredicateDefinition_Head(); |
| 1609 | 1859 | ||
| 1610 | /** | 1860 | /** |
| 1611 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol <em>Data Symbol</em>}'. | 1861 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition <em>Metric Definition</em>}'. |
| 1612 | * <!-- begin-user-doc --> | 1862 | * <!-- begin-user-doc --> |
| 1613 | * <!-- end-user-doc --> | 1863 | * <!-- end-user-doc --> |
| 1614 | * @return the meta object for class '<em>Data Symbol</em>'. | 1864 | * @return the meta object for class '<em>Metric Definition</em>'. |
| 1615 | * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol | 1865 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition |
| 1616 | * @generated | 1866 | * @generated |
| 1617 | */ | 1867 | */ |
| 1618 | EClass getDataSymbol(); | 1868 | EClass getMetricDefinition(); |
| 1619 | 1869 | ||
| 1620 | /** | 1870 | /** |
| 1621 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol <em>Boolean Symbol</em>}'. | 1871 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getHead <em>Head</em>}'. |
| 1622 | * <!-- begin-user-doc --> | 1872 | * <!-- begin-user-doc --> |
| 1623 | * <!-- end-user-doc --> | 1873 | * <!-- end-user-doc --> |
| 1624 | * @return the meta object for class '<em>Boolean Symbol</em>'. | 1874 | * @return the meta object for the containment reference '<em>Head</em>'. |
| 1625 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol | 1875 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getHead() |
| 1876 | * @see #getMetricDefinition() | ||
| 1626 | * @generated | 1877 | * @generated |
| 1627 | */ | 1878 | */ |
| 1628 | EClass getBooleanSymbol(); | 1879 | EReference getMetricDefinition_Head(); |
| 1629 | 1880 | ||
| 1630 | /** | 1881 | /** |
| 1631 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol <em>Integer Symbol</em>}'. | 1882 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getBody <em>Body</em>}'. |
| 1632 | * <!-- begin-user-doc --> | 1883 | * <!-- begin-user-doc --> |
| 1633 | * <!-- end-user-doc --> | 1884 | * <!-- end-user-doc --> |
| 1634 | * @return the meta object for class '<em>Integer Symbol</em>'. | 1885 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1635 | * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol | 1886 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getBody() |
| 1887 | * @see #getMetricDefinition() | ||
| 1636 | * @generated | 1888 | * @generated |
| 1637 | */ | 1889 | */ |
| 1638 | EClass getIntegerSymbol(); | 1890 | EReference getMetricDefinition_Body(); |
| 1639 | 1891 | ||
| 1640 | /** | 1892 | /** |
| 1641 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol <em>Real Symbol</em>}'. | 1893 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getType <em>Type</em>}'. |
| 1642 | * <!-- begin-user-doc --> | 1894 | * <!-- begin-user-doc --> |
| 1643 | * <!-- end-user-doc --> | 1895 | * <!-- end-user-doc --> |
| 1644 | * @return the meta object for class '<em>Real Symbol</em>'. | 1896 | * @return the meta object for the attribute '<em>Type</em>'. |
| 1645 | * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol | 1897 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition#getType() |
| 1898 | * @see #getMetricDefinition() | ||
| 1646 | * @generated | 1899 | * @generated |
| 1647 | */ | 1900 | */ |
| 1648 | EClass getRealSymbol(); | 1901 | EAttribute getMetricDefinition_Type(); |
| 1649 | 1902 | ||
| 1650 | /** | 1903 | /** |
| 1651 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol <em>String Symbol</em>}'. | 1904 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition <em>Extern Metric Definition</em>}'. |
| 1652 | * <!-- begin-user-doc --> | 1905 | * <!-- begin-user-doc --> |
| 1653 | * <!-- end-user-doc --> | 1906 | * <!-- end-user-doc --> |
| 1654 | * @return the meta object for class '<em>String Symbol</em>'. | 1907 | * @return the meta object for class '<em>Extern Metric Definition</em>'. |
| 1655 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol | 1908 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition |
| 1656 | * @generated | 1909 | * @generated |
| 1657 | */ | 1910 | */ |
| 1658 | EClass getStringSymbol(); | 1911 | EClass getExternMetricDefinition(); |
| 1659 | 1912 | ||
| 1660 | /** | 1913 | /** |
| 1661 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject <em>Complex Object</em>}'. | 1914 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getType <em>Type</em>}'. |
| 1662 | * <!-- begin-user-doc --> | 1915 | * <!-- begin-user-doc --> |
| 1663 | * <!-- end-user-doc --> | 1916 | * <!-- end-user-doc --> |
| 1664 | * @return the meta object for class '<em>Complex Object</em>'. | 1917 | * @return the meta object for the attribute '<em>Type</em>'. |
| 1665 | * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject | 1918 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getType() |
| 1919 | * @see #getExternMetricDefinition() | ||
| 1666 | * @generated | 1920 | * @generated |
| 1667 | */ | 1921 | */ |
| 1668 | EClass getComplexObject(); | 1922 | EAttribute getExternMetricDefinition_Type(); |
| 1669 | 1923 | ||
| 1670 | /** | 1924 | /** |
| 1671 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object <em>Object</em>}'. | 1925 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getHead <em>Head</em>}'. |
| 1672 | * <!-- begin-user-doc --> | 1926 | * <!-- begin-user-doc --> |
| 1673 | * <!-- end-user-doc --> | 1927 | * <!-- end-user-doc --> |
| 1674 | * @return the meta object for class '<em>Object</em>'. | 1928 | * @return the meta object for the containment reference '<em>Head</em>'. |
| 1675 | * @see org.eclipse.viatra.solver.language.solverLanguage.Object | 1929 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition#getHead() |
| 1930 | * @see #getExternMetricDefinition() | ||
| 1676 | * @generated | 1931 | * @generated |
| 1677 | */ | 1932 | */ |
| 1678 | EClass getObject(); | 1933 | EReference getExternMetricDefinition_Head(); |
| 1679 | 1934 | ||
| 1680 | /** | 1935 | /** |
| 1681 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject <em>Named Object</em>}'. | 1936 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Expression <em>Expression</em>}'. |
| 1682 | * <!-- begin-user-doc --> | 1937 | * <!-- begin-user-doc --> |
| 1683 | * <!-- end-user-doc --> | 1938 | * <!-- end-user-doc --> |
| 1684 | * @return the meta object for class '<em>Named Object</em>'. | 1939 | * @return the meta object for class '<em>Expression</em>'. |
| 1685 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject | 1940 | * @see org.eclipse.viatra.solver.language.solverLanguage.Expression |
| 1686 | * @generated | 1941 | * @generated |
| 1687 | */ | 1942 | */ |
| 1688 | EClass getNamedObject(); | 1943 | EClass getExpression(); |
| 1689 | 1944 | ||
| 1690 | /** | 1945 | /** |
| 1691 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}'. | 1946 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse <em>If Else</em>}'. |
| 1692 | * <!-- begin-user-doc --> | 1947 | * <!-- begin-user-doc --> |
| 1693 | * <!-- end-user-doc --> | 1948 | * <!-- end-user-doc --> |
| 1694 | * @return the meta object for the attribute '<em>Name</em>'. | 1949 | * @return the meta object for class '<em>If Else</em>'. |
| 1695 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName() | 1950 | * @see org.eclipse.viatra.solver.language.solverLanguage.IfElse |
| 1696 | * @see #getNamedObject() | ||
| 1697 | * @generated | 1951 | * @generated |
| 1698 | */ | 1952 | */ |
| 1699 | EAttribute getNamedObject_Name(); | 1953 | EClass getIfElse(); |
| 1700 | 1954 | ||
| 1701 | /** | 1955 | /** |
| 1702 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject <em>Unnamed Object</em>}'. | 1956 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getCondition <em>Condition</em>}'. |
| 1703 | * <!-- begin-user-doc --> | 1957 | * <!-- begin-user-doc --> |
| 1704 | * <!-- end-user-doc --> | 1958 | * <!-- end-user-doc --> |
| 1705 | * @return the meta object for class '<em>Unnamed Object</em>'. | 1959 | * @return the meta object for the containment reference '<em>Condition</em>'. |
| 1706 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject | 1960 | * @see org.eclipse.viatra.solver.language.solverLanguage.IfElse#getCondition() |
| 1961 | * @see #getIfElse() | ||
| 1707 | * @generated | 1962 | * @generated |
| 1708 | */ | 1963 | */ |
| 1709 | EClass getUnnamedObject(); | 1964 | EReference getIfElse_Condition(); |
| 1710 | 1965 | ||
| 1711 | /** | 1966 | /** |
| 1712 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}'. | 1967 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getThen <em>Then</em>}'. |
| 1713 | * <!-- begin-user-doc --> | 1968 | * <!-- begin-user-doc --> |
| 1714 | * <!-- end-user-doc --> | 1969 | * <!-- end-user-doc --> |
| 1715 | * @return the meta object for the attribute '<em>Name</em>'. | 1970 | * @return the meta object for the containment reference '<em>Then</em>'. |
| 1716 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName() | 1971 | * @see org.eclipse.viatra.solver.language.solverLanguage.IfElse#getThen() |
| 1717 | * @see #getUnnamedObject() | 1972 | * @see #getIfElse() |
| 1718 | * @generated | 1973 | * @generated |
| 1719 | */ | 1974 | */ |
| 1720 | EAttribute getUnnamedObject_Name(); | 1975 | EReference getIfElse_Then(); |
| 1721 | 1976 | ||
| 1722 | /** | 1977 | /** |
| 1723 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject <em>Data Object</em>}'. | 1978 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse#getElse <em>Else</em>}'. |
| 1724 | * <!-- begin-user-doc --> | 1979 | * <!-- begin-user-doc --> |
| 1725 | * <!-- end-user-doc --> | 1980 | * <!-- end-user-doc --> |
| 1726 | * @return the meta object for class '<em>Data Object</em>'. | 1981 | * @return the meta object for the containment reference '<em>Else</em>'. |
| 1727 | * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject | 1982 | * @see org.eclipse.viatra.solver.language.solverLanguage.IfElse#getElse() |
| 1983 | * @see #getIfElse() | ||
| 1728 | * @generated | 1984 | * @generated |
| 1729 | */ | 1985 | */ |
| 1730 | EClass getDataObject(); | 1986 | EReference getIfElse_Else(); |
| 1731 | 1987 | ||
| 1732 | /** | 1988 | /** |
| 1733 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject <em>Boolean Object</em>}'. | 1989 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Case <em>Case</em>}'. |
| 1734 | * <!-- begin-user-doc --> | 1990 | * <!-- begin-user-doc --> |
| 1735 | * <!-- end-user-doc --> | 1991 | * <!-- end-user-doc --> |
| 1736 | * @return the meta object for class '<em>Boolean Object</em>'. | 1992 | * @return the meta object for class '<em>Case</em>'. |
| 1737 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject | 1993 | * @see org.eclipse.viatra.solver.language.solverLanguage.Case |
| 1738 | * @generated | 1994 | * @generated |
| 1739 | */ | 1995 | */ |
| 1740 | EClass getBooleanObject(); | 1996 | EClass getCase(); |
| 1741 | 1997 | ||
| 1742 | /** | 1998 | /** |
| 1743 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}'. | 1999 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getCondition <em>Condition</em>}'. |
| 1744 | * <!-- begin-user-doc --> | 2000 | * <!-- begin-user-doc --> |
| 1745 | * <!-- end-user-doc --> | 2001 | * <!-- end-user-doc --> |
| 1746 | * @return the meta object for the containment reference '<em>Value</em>'. | 2002 | * @return the meta object for the containment reference '<em>Condition</em>'. |
| 1747 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue() | 2003 | * @see org.eclipse.viatra.solver.language.solverLanguage.Case#getCondition() |
| 1748 | * @see #getBooleanObject() | 2004 | * @see #getCase() |
| 1749 | * @generated | 2005 | * @generated |
| 1750 | */ | 2006 | */ |
| 1751 | EReference getBooleanObject_Value(); | 2007 | EReference getCase_Condition(); |
| 1752 | 2008 | ||
| 1753 | /** | 2009 | /** |
| 1754 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject <em>Int Object</em>}'. | 2010 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Case#getBody <em>Body</em>}'. |
| 1755 | * <!-- begin-user-doc --> | 2011 | * <!-- begin-user-doc --> |
| 1756 | * <!-- end-user-doc --> | 2012 | * <!-- end-user-doc --> |
| 1757 | * @return the meta object for class '<em>Int Object</em>'. | 2013 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1758 | * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject | 2014 | * @see org.eclipse.viatra.solver.language.solverLanguage.Case#getBody() |
| 2015 | * @see #getCase() | ||
| 1759 | * @generated | 2016 | * @generated |
| 1760 | */ | 2017 | */ |
| 1761 | EClass getIntObject(); | 2018 | EReference getCase_Body(); |
| 1762 | 2019 | ||
| 1763 | /** | 2020 | /** |
| 1764 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}'. | 2021 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Count <em>Count</em>}'. |
| 1765 | * <!-- begin-user-doc --> | 2022 | * <!-- begin-user-doc --> |
| 1766 | * <!-- end-user-doc --> | 2023 | * <!-- end-user-doc --> |
| 1767 | * @return the meta object for the attribute '<em>Value</em>'. | 2024 | * @return the meta object for class '<em>Count</em>'. |
| 1768 | * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue() | 2025 | * @see org.eclipse.viatra.solver.language.solverLanguage.Count |
| 1769 | * @see #getIntObject() | ||
| 1770 | * @generated | 2026 | * @generated |
| 1771 | */ | 2027 | */ |
| 1772 | EAttribute getIntObject_Value(); | 2028 | EClass getCount(); |
| 1773 | 2029 | ||
| 1774 | /** | 2030 | /** |
| 1775 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject <em>Real Object</em>}'. | 2031 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Count#getBody <em>Body</em>}'. |
| 1776 | * <!-- begin-user-doc --> | 2032 | * <!-- begin-user-doc --> |
| 1777 | * <!-- end-user-doc --> | 2033 | * <!-- end-user-doc --> |
| 1778 | * @return the meta object for class '<em>Real Object</em>'. | 2034 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1779 | * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject | 2035 | * @see org.eclipse.viatra.solver.language.solverLanguage.Count#getBody() |
| 2036 | * @see #getCount() | ||
| 1780 | * @generated | 2037 | * @generated |
| 1781 | */ | 2038 | */ |
| 1782 | EClass getRealObject(); | 2039 | EReference getCount_Body(); |
| 1783 | 2040 | ||
| 1784 | /** | 2041 | /** |
| 1785 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}'. | 2042 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation <em>Aggregation</em>}'. |
| 1786 | * <!-- begin-user-doc --> | 2043 | * <!-- begin-user-doc --> |
| 1787 | * <!-- end-user-doc --> | 2044 | * <!-- end-user-doc --> |
| 1788 | * @return the meta object for the attribute '<em>Value</em>'. | 2045 | * @return the meta object for class '<em>Aggregation</em>'. |
| 1789 | * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue() | 2046 | * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation |
| 1790 | * @see #getRealObject() | ||
| 1791 | * @generated | 2047 | * @generated |
| 1792 | */ | 2048 | */ |
| 1793 | EAttribute getRealObject_Value(); | 2049 | EClass getAggregation(); |
| 1794 | 2050 | ||
| 1795 | /** | 2051 | /** |
| 1796 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject <em>String Object</em>}'. | 2052 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getOp <em>Op</em>}'. |
| 1797 | * <!-- begin-user-doc --> | 2053 | * <!-- begin-user-doc --> |
| 1798 | * <!-- end-user-doc --> | 2054 | * <!-- end-user-doc --> |
| 1799 | * @return the meta object for class '<em>String Object</em>'. | 2055 | * @return the meta object for the attribute '<em>Op</em>'. |
| 1800 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject | 2056 | * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getOp() |
| 2057 | * @see #getAggregation() | ||
| 1801 | * @generated | 2058 | * @generated |
| 1802 | */ | 2059 | */ |
| 1803 | EClass getStringObject(); | 2060 | EAttribute getAggregation_Op(); |
| 1804 | 2061 | ||
| 1805 | /** | 2062 | /** |
| 1806 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}'. | 2063 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getBody <em>Body</em>}'. |
| 1807 | * <!-- begin-user-doc --> | 2064 | * <!-- begin-user-doc --> |
| 1808 | * <!-- end-user-doc --> | 2065 | * <!-- end-user-doc --> |
| 1809 | * @return the meta object for the attribute '<em>Value</em>'. | 2066 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1810 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue() | 2067 | * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getBody() |
| 1811 | * @see #getStringObject() | 2068 | * @see #getAggregation() |
| 2069 | * @generated | ||
| 2070 | */ | ||
| 2071 | EReference getAggregation_Body(); | ||
| 2072 | |||
| 2073 | /** | ||
| 2074 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getCondition <em>Condition</em>}'. | ||
| 2075 | * <!-- begin-user-doc --> | ||
| 2076 | * <!-- end-user-doc --> | ||
| 2077 | * @return the meta object for the containment reference '<em>Condition</em>'. | ||
| 2078 | * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation#getCondition() | ||
| 2079 | * @see #getAggregation() | ||
| 2080 | * @generated | ||
| 2081 | */ | ||
| 2082 | EReference getAggregation_Condition(); | ||
| 2083 | |||
| 2084 | /** | ||
| 2085 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Call <em>Call</em>}'. | ||
| 2086 | * <!-- begin-user-doc --> | ||
| 2087 | * <!-- end-user-doc --> | ||
| 2088 | * @return the meta object for class '<em>Call</em>'. | ||
| 2089 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call | ||
| 2090 | * @generated | ||
| 2091 | */ | ||
| 2092 | EClass getCall(); | ||
| 2093 | |||
| 2094 | /** | ||
| 2095 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getFunctor <em>Functor</em>}'. | ||
| 2096 | * <!-- begin-user-doc --> | ||
| 2097 | * <!-- end-user-doc --> | ||
| 2098 | * @return the meta object for the containment reference '<em>Functor</em>'. | ||
| 2099 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call#getFunctor() | ||
| 2100 | * @see #getCall() | ||
| 2101 | * @generated | ||
| 2102 | */ | ||
| 2103 | EReference getCall_Functor(); | ||
| 2104 | |||
| 2105 | /** | ||
| 2106 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isTransitiveClosure <em>Transitive Closure</em>}'. | ||
| 2107 | * <!-- begin-user-doc --> | ||
| 2108 | * <!-- end-user-doc --> | ||
| 2109 | * @return the meta object for the attribute '<em>Transitive Closure</em>'. | ||
| 2110 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call#isTransitiveClosure() | ||
| 2111 | * @see #getCall() | ||
| 1812 | * @generated | 2112 | * @generated |
| 1813 | */ | 2113 | */ |
| 1814 | EAttribute getStringObject_Value(); | 2114 | EAttribute getCall_TransitiveClosure(); |
| 1815 | 2115 | ||
| 1816 | /** | 2116 | /** |
| 1817 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate <em>Predicate</em>}'. | 2117 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#isReflexiveTransitiveClosure <em>Reflexive Transitive Closure</em>}'. |
| 1818 | * <!-- begin-user-doc --> | 2118 | * <!-- begin-user-doc --> |
| 1819 | * <!-- end-user-doc --> | 2119 | * <!-- end-user-doc --> |
| 1820 | * @return the meta object for class '<em>Predicate</em>'. | 2120 | * @return the meta object for the attribute '<em>Reflexive Transitive Closure</em>'. |
| 1821 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate | 2121 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call#isReflexiveTransitiveClosure() |
| 2122 | * @see #getCall() | ||
| 1822 | * @generated | 2123 | * @generated |
| 1823 | */ | 2124 | */ |
| 1824 | EClass getPredicate(); | 2125 | EAttribute getCall_ReflexiveTransitiveClosure(); |
| 1825 | 2126 | ||
| 1826 | /** | 2127 | /** |
| 1827 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#isIsError <em>Is Error</em>}'. | 2128 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Call#getArgumentList <em>Argument List</em>}'. |
| 1828 | * <!-- begin-user-doc --> | 2129 | * <!-- begin-user-doc --> |
| 1829 | * <!-- end-user-doc --> | 2130 | * <!-- end-user-doc --> |
| 1830 | * @return the meta object for the attribute '<em>Is Error</em>'. | 2131 | * @return the meta object for the containment reference '<em>Argument List</em>'. |
| 1831 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#isIsError() | 2132 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call#getArgumentList() |
| 1832 | * @see #getPredicate() | 2133 | * @see #getCall() |
| 1833 | * @generated | 2134 | * @generated |
| 1834 | */ | 2135 | */ |
| 1835 | EAttribute getPredicate_IsError(); | 2136 | EReference getCall_ArgumentList(); |
| 1836 | 2137 | ||
| 1837 | /** | 2138 | /** |
| 1838 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getSymbol <em>Symbol</em>}'. | 2139 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ArgumentList <em>Argument List</em>}'. |
| 1839 | * <!-- begin-user-doc --> | 2140 | * <!-- begin-user-doc --> |
| 1840 | * <!-- end-user-doc --> | 2141 | * <!-- end-user-doc --> |
| 1841 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2142 | * @return the meta object for class '<em>Argument List</em>'. |
| 1842 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getSymbol() | 2143 | * @see org.eclipse.viatra.solver.language.solverLanguage.ArgumentList |
| 1843 | * @see #getPredicate() | ||
| 1844 | * @generated | 2144 | * @generated |
| 1845 | */ | 2145 | */ |
| 1846 | EReference getPredicate_Symbol(); | 2146 | EClass getArgumentList(); |
| 1847 | 2147 | ||
| 1848 | /** | 2148 | /** |
| 1849 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters <em>Parameters</em>}'. | 2149 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ArgumentList#getArguments <em>Arguments</em>}'. |
| 1850 | * <!-- begin-user-doc --> | 2150 | * <!-- begin-user-doc --> |
| 1851 | * <!-- end-user-doc --> | 2151 | * <!-- end-user-doc --> |
| 1852 | * @return the meta object for the containment reference list '<em>Parameters</em>'. | 2152 | * @return the meta object for the containment reference list '<em>Arguments</em>'. |
| 1853 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters() | 2153 | * @see org.eclipse.viatra.solver.language.solverLanguage.ArgumentList#getArguments() |
| 1854 | * @see #getPredicate() | 2154 | * @see #getArgumentList() |
| 1855 | * @generated | 2155 | * @generated |
| 1856 | */ | 2156 | */ |
| 1857 | EReference getPredicate_Parameters(); | 2157 | EReference getArgumentList_Arguments(); |
| 1858 | 2158 | ||
| 1859 | /** | 2159 | /** |
| 1860 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies <em>Bodies</em>}'. | 2160 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Argument <em>Argument</em>}'. |
| 1861 | * <!-- begin-user-doc --> | 2161 | * <!-- begin-user-doc --> |
| 1862 | * <!-- end-user-doc --> | 2162 | * <!-- end-user-doc --> |
| 1863 | * @return the meta object for the containment reference list '<em>Bodies</em>'. | 2163 | * @return the meta object for class '<em>Argument</em>'. |
| 1864 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies() | 2164 | * @see org.eclipse.viatra.solver.language.solverLanguage.Argument |
| 1865 | * @see #getPredicate() | ||
| 1866 | * @generated | 2165 | * @generated |
| 1867 | */ | 2166 | */ |
| 1868 | EReference getPredicate_Bodies(); | 2167 | EClass getArgument(); |
| 1869 | 2168 | ||
| 1870 | /** | 2169 | /** |
| 1871 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter <em>Parameter</em>}'. | 2170 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument <em>Expression Argument</em>}'. |
| 1872 | * <!-- begin-user-doc --> | 2171 | * <!-- begin-user-doc --> |
| 1873 | * <!-- end-user-doc --> | 2172 | * <!-- end-user-doc --> |
| 1874 | * @return the meta object for class '<em>Parameter</em>'. | 2173 | * @return the meta object for class '<em>Expression Argument</em>'. |
| 1875 | * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter | 2174 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument |
| 1876 | * @generated | 2175 | * @generated |
| 1877 | */ | 2176 | */ |
| 1878 | EClass getParameter(); | 2177 | EClass getExpressionArgument(); |
| 1879 | 2178 | ||
| 1880 | /** | 2179 | /** |
| 1881 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}'. | 2180 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument#getBody <em>Body</em>}'. |
| 1882 | * <!-- begin-user-doc --> | 2181 | * <!-- begin-user-doc --> |
| 1883 | * <!-- end-user-doc --> | 2182 | * <!-- end-user-doc --> |
| 1884 | * @return the meta object for the containment reference '<em>Variable</em>'. | 2183 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 1885 | * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable() | 2184 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument#getBody() |
| 1886 | * @see #getParameter() | 2185 | * @see #getExpressionArgument() |
| 1887 | * @generated | 2186 | * @generated |
| 1888 | */ | 2187 | */ |
| 1889 | EReference getParameter_Variable(); | 2188 | EReference getExpressionArgument_Body(); |
| 1890 | 2189 | ||
| 1891 | /** | 2190 | /** |
| 1892 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}'. | 2191 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StarArgument <em>Star Argument</em>}'. |
| 1893 | * <!-- begin-user-doc --> | 2192 | * <!-- begin-user-doc --> |
| 1894 | * <!-- end-user-doc --> | 2193 | * <!-- end-user-doc --> |
| 1895 | * @return the meta object for the containment reference '<em>Type</em>'. | 2194 | * @return the meta object for class '<em>Star Argument</em>'. |
| 1896 | * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType() | 2195 | * @see org.eclipse.viatra.solver.language.solverLanguage.StarArgument |
| 1897 | * @see #getParameter() | ||
| 1898 | * @generated | 2196 | * @generated |
| 1899 | */ | 2197 | */ |
| 1900 | EReference getParameter_Type(); | 2198 | EClass getStarArgument(); |
| 1901 | 2199 | ||
| 1902 | /** | 2200 | /** |
| 1903 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody <em>Pattern Body</em>}'. | 2201 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument <em>Typed Argument</em>}'. |
| 1904 | * <!-- begin-user-doc --> | 2202 | * <!-- begin-user-doc --> |
| 1905 | * <!-- end-user-doc --> | 2203 | * <!-- end-user-doc --> |
| 1906 | * @return the meta object for class '<em>Pattern Body</em>'. | 2204 | * @return the meta object for class '<em>Typed Argument</em>'. |
| 1907 | * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody | 2205 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedArgument |
| 1908 | * @generated | 2206 | * @generated |
| 1909 | */ | 2207 | */ |
| 1910 | EClass getPatternBody(); | 2208 | EClass getTypedArgument(); |
| 1911 | 2209 | ||
| 1912 | /** | 2210 | /** |
| 1913 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints <em>Constraints</em>}'. | 2211 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getType <em>Type</em>}'. |
| 1914 | * <!-- begin-user-doc --> | 2212 | * <!-- begin-user-doc --> |
| 1915 | * <!-- end-user-doc --> | 2213 | * <!-- end-user-doc --> |
| 1916 | * @return the meta object for the containment reference list '<em>Constraints</em>'. | 2214 | * @return the meta object for the reference '<em>Type</em>'. |
| 1917 | * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints() | 2215 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getType() |
| 1918 | * @see #getPatternBody() | 2216 | * @see #getTypedArgument() |
| 1919 | * @generated | 2217 | * @generated |
| 1920 | */ | 2218 | */ |
| 1921 | EReference getPatternBody_Constraints(); | 2219 | EReference getTypedArgument_Type(); |
| 1922 | 2220 | ||
| 1923 | /** | 2221 | /** |
| 1924 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity <em>Polarity</em>}'. | 2222 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getVariable <em>Variable</em>}'. |
| 1925 | * <!-- begin-user-doc --> | 2223 | * <!-- begin-user-doc --> |
| 1926 | * <!-- end-user-doc --> | 2224 | * <!-- end-user-doc --> |
| 1927 | * @return the meta object for class '<em>Polarity</em>'. | 2225 | * @return the meta object for the reference '<em>Variable</em>'. |
| 1928 | * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity | 2226 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getVariable() |
| 2227 | * @see #getTypedArgument() | ||
| 1929 | * @generated | 2228 | * @generated |
| 1930 | */ | 2229 | */ |
| 1931 | EClass getPolarity(); | 2230 | EReference getTypedArgument_Variable(); |
| 1932 | 2231 | ||
| 1933 | /** | 2232 | /** |
| 1934 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint <em>Constraint</em>}'. | 2233 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument <em>Typed Star Argument</em>}'. |
| 1935 | * <!-- begin-user-doc --> | 2234 | * <!-- begin-user-doc --> |
| 1936 | * <!-- end-user-doc --> | 2235 | * <!-- end-user-doc --> |
| 1937 | * @return the meta object for class '<em>Constraint</em>'. | 2236 | * @return the meta object for class '<em>Typed Star Argument</em>'. |
| 1938 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint | 2237 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument |
| 1939 | * @generated | 2238 | * @generated |
| 1940 | */ | 2239 | */ |
| 1941 | EClass getConstraint(); | 2240 | EClass getTypedStarArgument(); |
| 1942 | 2241 | ||
| 1943 | /** | 2242 | /** |
| 1944 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}'. | 2243 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument#getType <em>Type</em>}'. |
| 1945 | * <!-- begin-user-doc --> | 2244 | * <!-- begin-user-doc --> |
| 1946 | * <!-- end-user-doc --> | 2245 | * <!-- end-user-doc --> |
| 1947 | * @return the meta object for the containment reference '<em>Polarity</em>'. | 2246 | * @return the meta object for the reference '<em>Type</em>'. |
| 1948 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity() | 2247 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument#getType() |
| 1949 | * @see #getConstraint() | 2248 | * @see #getTypedStarArgument() |
| 1950 | * @generated | 2249 | * @generated |
| 1951 | */ | 2250 | */ |
| 1952 | EReference getConstraint_Polarity(); | 2251 | EReference getTypedStarArgument_Type(); |
| 1953 | 2252 | ||
| 1954 | /** | 2253 | /** |
| 1955 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}'. | 2254 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Reference <em>Reference</em>}'. |
| 1956 | * <!-- begin-user-doc --> | 2255 | * <!-- begin-user-doc --> |
| 1957 | * <!-- end-user-doc --> | 2256 | * <!-- end-user-doc --> |
| 1958 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2257 | * @return the meta object for class '<em>Reference</em>'. |
| 1959 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol() | 2258 | * @see org.eclipse.viatra.solver.language.solverLanguage.Reference |
| 1960 | * @see #getConstraint() | ||
| 1961 | * @generated | 2259 | * @generated |
| 1962 | */ | 2260 | */ |
| 1963 | EReference getConstraint_Symbol(); | 2261 | EClass getReference(); |
| 1964 | 2262 | ||
| 1965 | /** | 2263 | /** |
| 1966 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams <em>Params</em>}'. | 2264 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Reference#getReferred <em>Referred</em>}'. |
| 1967 | * <!-- begin-user-doc --> | 2265 | * <!-- begin-user-doc --> |
| 1968 | * <!-- end-user-doc --> | 2266 | * <!-- end-user-doc --> |
| 1969 | * @return the meta object for the containment reference list '<em>Params</em>'. | 2267 | * @return the meta object for the reference '<em>Referred</em>'. |
| 1970 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams() | 2268 | * @see org.eclipse.viatra.solver.language.solverLanguage.Reference#getReferred() |
| 1971 | * @see #getConstraint() | 2269 | * @see #getReference() |
| 1972 | * @generated | 2270 | * @generated |
| 1973 | */ | 2271 | */ |
| 1974 | EReference getConstraint_Params(); | 2272 | EReference getReference_Referred(); |
| 1975 | 2273 | ||
| 1976 | /** | 2274 | /** |
| 1977 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}'. | 2275 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval <em>Interval</em>}'. |
| 1978 | * <!-- begin-user-doc --> | 2276 | * <!-- begin-user-doc --> |
| 1979 | * <!-- end-user-doc --> | 2277 | * <!-- end-user-doc --> |
| 1980 | * @return the meta object for the containment reference '<em>Closure Type</em>'. | 2278 | * @return the meta object for class '<em>Interval</em>'. |
| 1981 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType() | 2279 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interval |
| 1982 | * @see #getConstraint() | ||
| 1983 | * @generated | 2280 | * @generated |
| 1984 | */ | 2281 | */ |
| 1985 | EReference getConstraint_ClosureType(); | 2282 | EClass getInterval(); |
| 1986 | 2283 | ||
| 1987 | /** | 2284 | /** |
| 1988 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType <em>Closure Type</em>}'. | 2285 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getLowerBound <em>Lower Bound</em>}'. |
| 1989 | * <!-- begin-user-doc --> | 2286 | * <!-- begin-user-doc --> |
| 1990 | * <!-- end-user-doc --> | 2287 | * <!-- end-user-doc --> |
| 1991 | * @return the meta object for class '<em>Closure Type</em>'. | 2288 | * @return the meta object for the containment reference '<em>Lower Bound</em>'. |
| 1992 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType | 2289 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interval#getLowerBound() |
| 2290 | * @see #getInterval() | ||
| 1993 | * @generated | 2291 | * @generated |
| 1994 | */ | 2292 | */ |
| 1995 | EClass getClosureType(); | 2293 | EReference getInterval_LowerBound(); |
| 2294 | |||
| 2295 | /** | ||
| 2296 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval#getUpperBound <em>Upper Bound</em>}'. | ||
| 2297 | * <!-- begin-user-doc --> | ||
| 2298 | * <!-- end-user-doc --> | ||
| 2299 | * @return the meta object for the containment reference '<em>Upper Bound</em>'. | ||
| 2300 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interval#getUpperBound() | ||
| 2301 | * @see #getInterval() | ||
| 2302 | * @generated | ||
| 2303 | */ | ||
| 2304 | EReference getInterval_UpperBound(); | ||
| 1996 | 2305 | ||
| 1997 | /** | 2306 | /** |
| 1998 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'. | 2307 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'. |
| @@ -2005,446 +2314,700 @@ public interface SolverLanguagePackage extends EPackage | |||
| 2005 | EClass getLiteral(); | 2314 | EClass getLiteral(); |
| 2006 | 2315 | ||
| 2007 | /** | 2316 | /** |
| 2008 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable <em>Variable</em>}'. | 2317 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral <em>Logic Literal</em>}'. |
| 2009 | * <!-- begin-user-doc --> | 2318 | * <!-- begin-user-doc --> |
| 2010 | * <!-- end-user-doc --> | 2319 | * <!-- end-user-doc --> |
| 2011 | * @return the meta object for class '<em>Variable</em>'. | 2320 | * @return the meta object for class '<em>Logic Literal</em>'. |
| 2012 | * @see org.eclipse.viatra.solver.language.solverLanguage.Variable | 2321 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral |
| 2013 | * @generated | 2322 | * @generated |
| 2014 | */ | 2323 | */ |
| 2015 | EClass getVariable(); | 2324 | EClass getLogicLiteral(); |
| 2016 | 2325 | ||
| 2017 | /** | 2326 | /** |
| 2018 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}'. | 2327 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral#getValue <em>Value</em>}'. |
| 2019 | * <!-- begin-user-doc --> | 2328 | * <!-- begin-user-doc --> |
| 2020 | * <!-- end-user-doc --> | 2329 | * <!-- end-user-doc --> |
| 2021 | * @return the meta object for the attribute '<em>Name</em>'. | 2330 | * @return the meta object for the attribute '<em>Value</em>'. |
| 2022 | * @see org.eclipse.viatra.solver.language.solverLanguage.Variable#getName() | 2331 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral#getValue() |
| 2023 | * @see #getVariable() | 2332 | * @see #getLogicLiteral() |
| 2024 | * @generated | 2333 | * @generated |
| 2025 | */ | 2334 | */ |
| 2026 | EAttribute getVariable_Name(); | 2335 | EAttribute getLogicLiteral_Value(); |
| 2027 | 2336 | ||
| 2028 | /** | 2337 | /** |
| 2029 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances <em>All Instances</em>}'. | 2338 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral <em>Numeric Literal</em>}'. |
| 2030 | * <!-- begin-user-doc --> | 2339 | * <!-- begin-user-doc --> |
| 2031 | * <!-- end-user-doc --> | 2340 | * <!-- end-user-doc --> |
| 2032 | * @return the meta object for class '<em>All Instances</em>'. | 2341 | * @return the meta object for class '<em>Numeric Literal</em>'. |
| 2033 | * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances | 2342 | * @see org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral |
| 2034 | * @generated | 2343 | * @generated |
| 2035 | */ | 2344 | */ |
| 2036 | EClass getAllInstances(); | 2345 | EClass getNumericLiteral(); |
| 2037 | 2346 | ||
| 2038 | /** | 2347 | /** |
| 2039 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}'. | 2348 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral#getValue <em>Value</em>}'. |
| 2040 | * <!-- begin-user-doc --> | 2349 | * <!-- begin-user-doc --> |
| 2041 | * <!-- end-user-doc --> | 2350 | * <!-- end-user-doc --> |
| 2042 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2351 | * @return the meta object for the attribute '<em>Value</em>'. |
| 2043 | * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol() | 2352 | * @see org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral#getValue() |
| 2044 | * @see #getAllInstances() | 2353 | * @see #getNumericLiteral() |
| 2045 | * @generated | 2354 | * @generated |
| 2046 | */ | 2355 | */ |
| 2047 | EReference getAllInstances_Symbol(); | 2356 | EAttribute getNumericLiteral_Value(); |
| 2048 | 2357 | ||
| 2049 | /** | 2358 | /** |
| 2050 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects <em>All Objects</em>}'. | 2359 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral <em>Infinity Literal</em>}'. |
| 2051 | * <!-- begin-user-doc --> | 2360 | * <!-- begin-user-doc --> |
| 2052 | * <!-- end-user-doc --> | 2361 | * <!-- end-user-doc --> |
| 2053 | * @return the meta object for class '<em>All Objects</em>'. | 2362 | * @return the meta object for class '<em>Infinity Literal</em>'. |
| 2054 | * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects | 2363 | * @see org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral |
| 2055 | * @generated | 2364 | * @generated |
| 2056 | */ | 2365 | */ |
| 2057 | EClass getAllObjects(); | 2366 | EClass getInfinityLiteral(); |
| 2058 | 2367 | ||
| 2059 | /** | 2368 | /** |
| 2060 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation <em>Default Interpretation</em>}'. | 2369 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral <em>Empty Interval Literal</em>}'. |
| 2061 | * <!-- begin-user-doc --> | 2370 | * <!-- begin-user-doc --> |
| 2062 | * <!-- end-user-doc --> | 2371 | * <!-- end-user-doc --> |
| 2063 | * @return the meta object for class '<em>Default Interpretation</em>'. | 2372 | * @return the meta object for class '<em>Empty Interval Literal</em>'. |
| 2064 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation | 2373 | * @see org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral |
| 2065 | * @generated | 2374 | * @generated |
| 2066 | */ | 2375 | */ |
| 2067 | EClass getDefaultInterpretation(); | 2376 | EClass getEmptyIntervalLiteral(); |
| 2068 | 2377 | ||
| 2069 | /** | 2378 | /** |
| 2070 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}'. | 2379 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral <em>String Literal</em>}'. |
| 2071 | * <!-- begin-user-doc --> | 2380 | * <!-- begin-user-doc --> |
| 2072 | * <!-- end-user-doc --> | 2381 | * <!-- end-user-doc --> |
| 2073 | * @return the meta object for the containment reference '<em>Interpretation</em>'. | 2382 | * @return the meta object for class '<em>String Literal</em>'. |
| 2074 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation() | 2383 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringLiteral |
| 2075 | * @see #getDefaultInterpretation() | ||
| 2076 | * @generated | 2384 | * @generated |
| 2077 | */ | 2385 | */ |
| 2078 | EReference getDefaultInterpretation_Interpretation(); | 2386 | EClass getStringLiteral(); |
| 2079 | 2387 | ||
| 2080 | /** | 2388 | /** |
| 2081 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation <em>CD Interpretation</em>}'. | 2389 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral#getValue <em>Value</em>}'. |
| 2082 | * <!-- begin-user-doc --> | 2390 | * <!-- begin-user-doc --> |
| 2083 | * <!-- end-user-doc --> | 2391 | * <!-- end-user-doc --> |
| 2084 | * @return the meta object for class '<em>CD Interpretation</em>'. | 2392 | * @return the meta object for the attribute '<em>Value</em>'. |
| 2085 | * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation | 2393 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringLiteral#getValue() |
| 2394 | * @see #getStringLiteral() | ||
| 2086 | * @generated | 2395 | * @generated |
| 2087 | */ | 2396 | */ |
| 2088 | EClass getCDInterpretation(); | 2397 | EAttribute getStringLiteral_Value(); |
| 2089 | 2398 | ||
| 2090 | /** | 2399 | /** |
| 2091 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation <em>Class Interpretation</em>}'. | 2400 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition <em>Class Definition</em>}'. |
| 2092 | * <!-- begin-user-doc --> | 2401 | * <!-- begin-user-doc --> |
| 2093 | * <!-- end-user-doc --> | 2402 | * <!-- end-user-doc --> |
| 2094 | * @return the meta object for class '<em>Class Interpretation</em>'. | 2403 | * @return the meta object for class '<em>Class Definition</em>'. |
| 2095 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation | 2404 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition |
| 2096 | * @generated | 2405 | * @generated |
| 2097 | */ | 2406 | */ |
| 2098 | EClass getClassInterpretation(); | 2407 | EClass getClassDefinition(); |
| 2099 | 2408 | ||
| 2100 | /** | 2409 | /** |
| 2101 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}'. | 2410 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#isAbstract <em>Abstract</em>}'. |
| 2102 | * <!-- begin-user-doc --> | 2411 | * <!-- begin-user-doc --> |
| 2103 | * <!-- end-user-doc --> | 2412 | * <!-- end-user-doc --> |
| 2104 | * @return the meta object for the attribute '<em>Abstract</em>'. | 2413 | * @return the meta object for the attribute '<em>Abstract</em>'. |
| 2105 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract() | 2414 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#isAbstract() |
| 2106 | * @see #getClassInterpretation() | 2415 | * @see #getClassDefinition() |
| 2416 | * @generated | ||
| 2417 | */ | ||
| 2418 | EAttribute getClassDefinition_Abstract(); | ||
| 2419 | |||
| 2420 | /** | ||
| 2421 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getName <em>Name</em>}'. | ||
| 2422 | * <!-- begin-user-doc --> | ||
| 2423 | * <!-- end-user-doc --> | ||
| 2424 | * @return the meta object for the attribute '<em>Name</em>'. | ||
| 2425 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getName() | ||
| 2426 | * @see #getClassDefinition() | ||
| 2107 | * @generated | 2427 | * @generated |
| 2108 | */ | 2428 | */ |
| 2109 | EAttribute getClassInterpretation_Abstract(); | 2429 | EAttribute getClassDefinition_Name(); |
| 2110 | 2430 | ||
| 2111 | /** | 2431 | /** |
| 2112 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}'. | 2432 | * Returns the meta object for the reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getSuperclasses <em>Superclasses</em>}'. |
| 2113 | * <!-- begin-user-doc --> | 2433 | * <!-- begin-user-doc --> |
| 2114 | * <!-- end-user-doc --> | 2434 | * <!-- end-user-doc --> |
| 2115 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2435 | * @return the meta object for the reference list '<em>Superclasses</em>'. |
| 2116 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol() | 2436 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getSuperclasses() |
| 2117 | * @see #getClassInterpretation() | 2437 | * @see #getClassDefinition() |
| 2118 | * @generated | 2438 | * @generated |
| 2119 | */ | 2439 | */ |
| 2120 | EReference getClassInterpretation_Symbol(); | 2440 | EReference getClassDefinition_Superclasses(); |
| 2121 | 2441 | ||
| 2122 | /** | 2442 | /** |
| 2123 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes <em>Supertypes</em>}'. | 2443 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getMembers <em>Members</em>}'. |
| 2124 | * <!-- begin-user-doc --> | 2444 | * <!-- begin-user-doc --> |
| 2125 | * <!-- end-user-doc --> | 2445 | * <!-- end-user-doc --> |
| 2126 | * @return the meta object for the containment reference list '<em>Supertypes</em>'. | 2446 | * @return the meta object for the containment reference list '<em>Members</em>'. |
| 2127 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes() | 2447 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition#getMembers() |
| 2128 | * @see #getClassInterpretation() | 2448 | * @see #getClassDefinition() |
| 2129 | * @generated | 2449 | * @generated |
| 2130 | */ | 2450 | */ |
| 2131 | EReference getClassInterpretation_Supertypes(); | 2451 | EReference getClassDefinition_Members(); |
| 2132 | 2452 | ||
| 2133 | /** | 2453 | /** |
| 2134 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt <em>Fielt</em>}'. | 2454 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition <em>Member Definition</em>}'. |
| 2135 | * <!-- begin-user-doc --> | 2455 | * <!-- begin-user-doc --> |
| 2136 | * <!-- end-user-doc --> | 2456 | * <!-- end-user-doc --> |
| 2137 | * @return the meta object for the containment reference list '<em>Fielt</em>'. | 2457 | * @return the meta object for class '<em>Member Definition</em>'. |
| 2138 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt() | 2458 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition |
| 2139 | * @see #getClassInterpretation() | ||
| 2140 | * @generated | 2459 | * @generated |
| 2141 | */ | 2460 | */ |
| 2142 | EReference getClassInterpretation_Fielt(); | 2461 | EClass getMemberDefinition(); |
| 2143 | 2462 | ||
| 2144 | /** | 2463 | /** |
| 2145 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation <em>Enum Interpretation</em>}'. | 2464 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#isContainment <em>Containment</em>}'. |
| 2146 | * <!-- begin-user-doc --> | 2465 | * <!-- begin-user-doc --> |
| 2147 | * <!-- end-user-doc --> | 2466 | * <!-- end-user-doc --> |
| 2148 | * @return the meta object for class '<em>Enum Interpretation</em>'. | 2467 | * @return the meta object for the attribute '<em>Containment</em>'. |
| 2149 | * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation | 2468 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#isContainment() |
| 2469 | * @see #getMemberDefinition() | ||
| 2150 | * @generated | 2470 | * @generated |
| 2151 | */ | 2471 | */ |
| 2152 | EClass getEnumInterpretation(); | 2472 | EAttribute getMemberDefinition_Containment(); |
| 2153 | 2473 | ||
| 2154 | /** | 2474 | /** |
| 2155 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}'. | 2475 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getType <em>Type</em>}'. |
| 2156 | * <!-- begin-user-doc --> | 2476 | * <!-- begin-user-doc --> |
| 2157 | * <!-- end-user-doc --> | 2477 | * <!-- end-user-doc --> |
| 2158 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2478 | * @return the meta object for the reference '<em>Type</em>'. |
| 2159 | * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol() | 2479 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getType() |
| 2160 | * @see #getEnumInterpretation() | 2480 | * @see #getMemberDefinition() |
| 2161 | * @generated | 2481 | * @generated |
| 2162 | */ | 2482 | */ |
| 2163 | EReference getEnumInterpretation_Symbol(); | 2483 | EReference getMemberDefinition_Type(); |
| 2164 | 2484 | ||
| 2165 | /** | 2485 | /** |
| 2166 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects <em>Objects</em>}'. | 2486 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getMultiplicity <em>Multiplicity</em>}'. |
| 2167 | * <!-- begin-user-doc --> | 2487 | * <!-- begin-user-doc --> |
| 2168 | * <!-- end-user-doc --> | 2488 | * <!-- end-user-doc --> |
| 2169 | * @return the meta object for the containment reference list '<em>Objects</em>'. | 2489 | * @return the meta object for the containment reference '<em>Multiplicity</em>'. |
| 2170 | * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects() | 2490 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getMultiplicity() |
| 2171 | * @see #getEnumInterpretation() | 2491 | * @see #getMemberDefinition() |
| 2172 | * @generated | 2492 | * @generated |
| 2173 | */ | 2493 | */ |
| 2174 | EReference getEnumInterpretation_Objects(); | 2494 | EReference getMemberDefinition_Multiplicity(); |
| 2175 | 2495 | ||
| 2176 | /** | 2496 | /** |
| 2177 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation <em>Field Relation Interpretation</em>}'. | 2497 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getName <em>Name</em>}'. |
| 2178 | * <!-- begin-user-doc --> | 2498 | * <!-- begin-user-doc --> |
| 2179 | * <!-- end-user-doc --> | 2499 | * <!-- end-user-doc --> |
| 2180 | * @return the meta object for class '<em>Field Relation Interpretation</em>'. | 2500 | * @return the meta object for the attribute '<em>Name</em>'. |
| 2181 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation | 2501 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getName() |
| 2502 | * @see #getMemberDefinition() | ||
| 2182 | * @generated | 2503 | * @generated |
| 2183 | */ | 2504 | */ |
| 2184 | EClass getFieldRelationInterpretation(); | 2505 | EAttribute getMemberDefinition_Name(); |
| 2185 | 2506 | ||
| 2186 | /** | 2507 | /** |
| 2187 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}'. | 2508 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getOpposite <em>Opposite</em>}'. |
| 2188 | * <!-- begin-user-doc --> | 2509 | * <!-- begin-user-doc --> |
| 2189 | * <!-- end-user-doc --> | 2510 | * <!-- end-user-doc --> |
| 2190 | * @return the meta object for the attribute '<em>Containment</em>'. | 2511 | * @return the meta object for the reference '<em>Opposite</em>'. |
| 2191 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment() | 2512 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition#getOpposite() |
| 2192 | * @see #getFieldRelationInterpretation() | 2513 | * @see #getMemberDefinition() |
| 2193 | * @generated | 2514 | * @generated |
| 2194 | */ | 2515 | */ |
| 2195 | EAttribute getFieldRelationInterpretation_Containment(); | 2516 | EReference getMemberDefinition_Opposite(); |
| 2196 | 2517 | ||
| 2197 | /** | 2518 | /** |
| 2198 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}'. | 2519 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Multiplicity <em>Multiplicity</em>}'. |
| 2199 | * <!-- begin-user-doc --> | 2520 | * <!-- begin-user-doc --> |
| 2200 | * <!-- end-user-doc --> | 2521 | * <!-- end-user-doc --> |
| 2201 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2522 | * @return the meta object for class '<em>Multiplicity</em>'. |
| 2202 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol() | 2523 | * @see org.eclipse.viatra.solver.language.solverLanguage.Multiplicity |
| 2203 | * @see #getFieldRelationInterpretation() | ||
| 2204 | * @generated | 2524 | * @generated |
| 2205 | */ | 2525 | */ |
| 2206 | EReference getFieldRelationInterpretation_Symbol(); | 2526 | EClass getMultiplicity(); |
| 2207 | 2527 | ||
| 2208 | /** | 2528 | /** |
| 2209 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}'. | 2529 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity <em>Many Multiplicity</em>}'. |
| 2210 | * <!-- begin-user-doc --> | 2530 | * <!-- begin-user-doc --> |
| 2211 | * <!-- end-user-doc --> | 2531 | * <!-- end-user-doc --> |
| 2212 | * @return the meta object for the containment reference '<em>Multiplicity</em>'. | 2532 | * @return the meta object for class '<em>Many Multiplicity</em>'. |
| 2213 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity() | 2533 | * @see org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity |
| 2214 | * @see #getFieldRelationInterpretation() | ||
| 2215 | * @generated | 2534 | * @generated |
| 2216 | */ | 2535 | */ |
| 2217 | EReference getFieldRelationInterpretation_Multiplicity(); | 2536 | EClass getManyMultiplicity(); |
| 2218 | 2537 | ||
| 2219 | /** | 2538 | /** |
| 2220 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}'. | 2539 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity <em>Exact Multiplicity</em>}'. |
| 2221 | * <!-- begin-user-doc --> | 2540 | * <!-- begin-user-doc --> |
| 2222 | * <!-- end-user-doc --> | 2541 | * <!-- end-user-doc --> |
| 2223 | * @return the meta object for the containment reference '<em>Target</em>'. | 2542 | * @return the meta object for class '<em>Exact Multiplicity</em>'. |
| 2224 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget() | 2543 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity |
| 2225 | * @see #getFieldRelationInterpretation() | ||
| 2226 | * @generated | 2544 | * @generated |
| 2227 | */ | 2545 | */ |
| 2228 | EReference getFieldRelationInterpretation_Target(); | 2546 | EClass getExactMultiplicity(); |
| 2229 | 2547 | ||
| 2230 | /** | 2548 | /** |
| 2231 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation <em>Global Relation Interpretation</em>}'. | 2549 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity#getMultiplicity <em>Multiplicity</em>}'. |
| 2232 | * <!-- begin-user-doc --> | 2550 | * <!-- begin-user-doc --> |
| 2233 | * <!-- end-user-doc --> | 2551 | * <!-- end-user-doc --> |
| 2234 | * @return the meta object for class '<em>Global Relation Interpretation</em>'. | 2552 | * @return the meta object for the attribute '<em>Multiplicity</em>'. |
| 2235 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation | 2553 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity#getMultiplicity() |
| 2554 | * @see #getExactMultiplicity() | ||
| 2236 | * @generated | 2555 | * @generated |
| 2237 | */ | 2556 | */ |
| 2238 | EClass getGlobalRelationInterpretation(); | 2557 | EAttribute getExactMultiplicity_Multiplicity(); |
| 2239 | 2558 | ||
| 2240 | /** | 2559 | /** |
| 2241 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}'. | 2560 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity <em>Bounded Multiplicity</em>}'. |
| 2242 | * <!-- begin-user-doc --> | 2561 | * <!-- begin-user-doc --> |
| 2243 | * <!-- end-user-doc --> | 2562 | * <!-- end-user-doc --> |
| 2244 | * @return the meta object for the attribute '<em>Containment</em>'. | 2563 | * @return the meta object for class '<em>Bounded Multiplicity</em>'. |
| 2245 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment() | 2564 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity |
| 2246 | * @see #getGlobalRelationInterpretation() | 2565 | * @generated |
| 2566 | */ | ||
| 2567 | EClass getBoundedMultiplicity(); | ||
| 2568 | |||
| 2569 | /** | ||
| 2570 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getLowerBound <em>Lower Bound</em>}'. | ||
| 2571 | * <!-- begin-user-doc --> | ||
| 2572 | * <!-- end-user-doc --> | ||
| 2573 | * @return the meta object for the attribute '<em>Lower Bound</em>'. | ||
| 2574 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getLowerBound() | ||
| 2575 | * @see #getBoundedMultiplicity() | ||
| 2576 | * @generated | ||
| 2577 | */ | ||
| 2578 | EAttribute getBoundedMultiplicity_LowerBound(); | ||
| 2579 | |||
| 2580 | /** | ||
| 2581 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getUpperBound <em>Upper Bound</em>}'. | ||
| 2582 | * <!-- begin-user-doc --> | ||
| 2583 | * <!-- end-user-doc --> | ||
| 2584 | * @return the meta object for the attribute '<em>Upper Bound</em>'. | ||
| 2585 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity#getUpperBound() | ||
| 2586 | * @see #getBoundedMultiplicity() | ||
| 2587 | * @generated | ||
| 2588 | */ | ||
| 2589 | EAttribute getBoundedMultiplicity_UpperBound(); | ||
| 2590 | |||
| 2591 | /** | ||
| 2592 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition <em>Scope Definition</em>}'. | ||
| 2593 | * <!-- begin-user-doc --> | ||
| 2594 | * <!-- end-user-doc --> | ||
| 2595 | * @return the meta object for class '<em>Scope Definition</em>'. | ||
| 2596 | * @see org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition | ||
| 2597 | * @generated | ||
| 2598 | */ | ||
| 2599 | EClass getScopeDefinition(); | ||
| 2600 | |||
| 2601 | /** | ||
| 2602 | * Returns the meta object for the reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition#getType <em>Type</em>}'. | ||
| 2603 | * <!-- begin-user-doc --> | ||
| 2604 | * <!-- end-user-doc --> | ||
| 2605 | * @return the meta object for the reference '<em>Type</em>'. | ||
| 2606 | * @see org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition#getType() | ||
| 2607 | * @see #getScopeDefinition() | ||
| 2608 | * @generated | ||
| 2609 | */ | ||
| 2610 | EReference getScopeDefinition_Type(); | ||
| 2611 | |||
| 2612 | /** | ||
| 2613 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition <em>Exact Scope Definition</em>}'. | ||
| 2614 | * <!-- begin-user-doc --> | ||
| 2615 | * <!-- end-user-doc --> | ||
| 2616 | * @return the meta object for class '<em>Exact Scope Definition</em>'. | ||
| 2617 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition | ||
| 2618 | * @generated | ||
| 2619 | */ | ||
| 2620 | EClass getExactScopeDefinition(); | ||
| 2621 | |||
| 2622 | /** | ||
| 2623 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition#getExactScope <em>Exact Scope</em>}'. | ||
| 2624 | * <!-- begin-user-doc --> | ||
| 2625 | * <!-- end-user-doc --> | ||
| 2626 | * @return the meta object for the attribute '<em>Exact Scope</em>'. | ||
| 2627 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition#getExactScope() | ||
| 2628 | * @see #getExactScopeDefinition() | ||
| 2629 | * @generated | ||
| 2630 | */ | ||
| 2631 | EAttribute getExactScopeDefinition_ExactScope(); | ||
| 2632 | |||
| 2633 | /** | ||
| 2634 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition <em>Bounded Scope Definition</em>}'. | ||
| 2635 | * <!-- begin-user-doc --> | ||
| 2636 | * <!-- end-user-doc --> | ||
| 2637 | * @return the meta object for class '<em>Bounded Scope Definition</em>'. | ||
| 2638 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition | ||
| 2639 | * @generated | ||
| 2640 | */ | ||
| 2641 | EClass getBoundedScopeDefinition(); | ||
| 2642 | |||
| 2643 | /** | ||
| 2644 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}'. | ||
| 2645 | * <!-- begin-user-doc --> | ||
| 2646 | * <!-- end-user-doc --> | ||
| 2647 | * @return the meta object for the attribute '<em>Lower Bound</em>'. | ||
| 2648 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getLowerBound() | ||
| 2649 | * @see #getBoundedScopeDefinition() | ||
| 2650 | * @generated | ||
| 2651 | */ | ||
| 2652 | EAttribute getBoundedScopeDefinition_LowerBound(); | ||
| 2653 | |||
| 2654 | /** | ||
| 2655 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getUpperBound <em>Upper Bound</em>}'. | ||
| 2656 | * <!-- begin-user-doc --> | ||
| 2657 | * <!-- end-user-doc --> | ||
| 2658 | * @return the meta object for the attribute '<em>Upper Bound</em>'. | ||
| 2659 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition#getUpperBound() | ||
| 2660 | * @see #getBoundedScopeDefinition() | ||
| 2661 | * @generated | ||
| 2662 | */ | ||
| 2663 | EAttribute getBoundedScopeDefinition_UpperBound(); | ||
| 2664 | |||
| 2665 | /** | ||
| 2666 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition <em>Lower Bounded Scope Definition</em>}'. | ||
| 2667 | * <!-- begin-user-doc --> | ||
| 2668 | * <!-- end-user-doc --> | ||
| 2669 | * @return the meta object for class '<em>Lower Bounded Scope Definition</em>'. | ||
| 2670 | * @see org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition | ||
| 2671 | * @generated | ||
| 2672 | */ | ||
| 2673 | EClass getLowerBoundedScopeDefinition(); | ||
| 2674 | |||
| 2675 | /** | ||
| 2676 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition#getLowerBound <em>Lower Bound</em>}'. | ||
| 2677 | * <!-- begin-user-doc --> | ||
| 2678 | * <!-- end-user-doc --> | ||
| 2679 | * @return the meta object for the attribute '<em>Lower Bound</em>'. | ||
| 2680 | * @see org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition#getLowerBound() | ||
| 2681 | * @see #getLowerBoundedScopeDefinition() | ||
| 2682 | * @generated | ||
| 2683 | */ | ||
| 2684 | EAttribute getLowerBoundedScopeDefinition_LowerBound(); | ||
| 2685 | |||
| 2686 | /** | ||
| 2687 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition <em>Objective Definition</em>}'. | ||
| 2688 | * <!-- begin-user-doc --> | ||
| 2689 | * <!-- end-user-doc --> | ||
| 2690 | * @return the meta object for class '<em>Objective Definition</em>'. | ||
| 2691 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition | ||
| 2692 | * @generated | ||
| 2693 | */ | ||
| 2694 | EClass getObjectiveDefinition(); | ||
| 2695 | |||
| 2696 | /** | ||
| 2697 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getKind <em>Kind</em>}'. | ||
| 2698 | * <!-- begin-user-doc --> | ||
| 2699 | * <!-- end-user-doc --> | ||
| 2700 | * @return the meta object for the attribute '<em>Kind</em>'. | ||
| 2701 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getKind() | ||
| 2702 | * @see #getObjectiveDefinition() | ||
| 2703 | * @generated | ||
| 2704 | */ | ||
| 2705 | EAttribute getObjectiveDefinition_Kind(); | ||
| 2706 | |||
| 2707 | /** | ||
| 2708 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getObjective <em>Objective</em>}'. | ||
| 2709 | * <!-- begin-user-doc --> | ||
| 2710 | * <!-- end-user-doc --> | ||
| 2711 | * @return the meta object for the containment reference '<em>Objective</em>'. | ||
| 2712 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition#getObjective() | ||
| 2713 | * @see #getObjectiveDefinition() | ||
| 2714 | * @generated | ||
| 2715 | */ | ||
| 2716 | EReference getObjectiveDefinition_Objective(); | ||
| 2717 | |||
| 2718 | /** | ||
| 2719 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement <em>Named Element</em>}'. | ||
| 2720 | * <!-- begin-user-doc --> | ||
| 2721 | * <!-- end-user-doc --> | ||
| 2722 | * @return the meta object for class '<em>Named Element</em>'. | ||
| 2723 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedElement | ||
| 2724 | * @generated | ||
| 2725 | */ | ||
| 2726 | EClass getNamedElement(); | ||
| 2727 | |||
| 2728 | /** | ||
| 2729 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement#getName <em>Name</em>}'. | ||
| 2730 | * <!-- begin-user-doc --> | ||
| 2731 | * <!-- end-user-doc --> | ||
| 2732 | * @return the meta object for the attribute '<em>Name</em>'. | ||
| 2733 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedElement#getName() | ||
| 2734 | * @see #getNamedElement() | ||
| 2735 | * @generated | ||
| 2736 | */ | ||
| 2737 | EAttribute getNamedElement_Name(); | ||
| 2738 | |||
| 2739 | /** | ||
| 2740 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion <em>Assertion</em>}'. | ||
| 2741 | * <!-- begin-user-doc --> | ||
| 2742 | * <!-- end-user-doc --> | ||
| 2743 | * @return the meta object for class '<em>Assertion</em>'. | ||
| 2744 | * @see org.eclipse.viatra.solver.language.solverLanguage.Assertion | ||
| 2247 | * @generated | 2745 | * @generated |
| 2248 | */ | 2746 | */ |
| 2249 | EAttribute getGlobalRelationInterpretation_Containment(); | 2747 | EClass getAssertion(); |
| 2250 | 2748 | ||
| 2251 | /** | 2749 | /** |
| 2252 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}'. | 2750 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getBody <em>Body</em>}'. |
| 2253 | * <!-- begin-user-doc --> | 2751 | * <!-- begin-user-doc --> |
| 2254 | * <!-- end-user-doc --> | 2752 | * <!-- end-user-doc --> |
| 2255 | * @return the meta object for the containment reference '<em>Symbol</em>'. | 2753 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 2256 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol() | 2754 | * @see org.eclipse.viatra.solver.language.solverLanguage.Assertion#getBody() |
| 2257 | * @see #getGlobalRelationInterpretation() | 2755 | * @see #getAssertion() |
| 2258 | * @generated | 2756 | * @generated |
| 2259 | */ | 2757 | */ |
| 2260 | EReference getGlobalRelationInterpretation_Symbol(); | 2758 | EReference getAssertion_Body(); |
| 2261 | 2759 | ||
| 2262 | /** | 2760 | /** |
| 2263 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}'. | 2761 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion#getRange <em>Range</em>}'. |
| 2264 | * <!-- begin-user-doc --> | 2762 | * <!-- begin-user-doc --> |
| 2265 | * <!-- end-user-doc --> | 2763 | * <!-- end-user-doc --> |
| 2266 | * @return the meta object for the containment reference '<em>Source Multiplicity</em>'. | 2764 | * @return the meta object for the containment reference '<em>Range</em>'. |
| 2267 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity() | 2765 | * @see org.eclipse.viatra.solver.language.solverLanguage.Assertion#getRange() |
| 2268 | * @see #getGlobalRelationInterpretation() | 2766 | * @see #getAssertion() |
| 2269 | * @generated | 2767 | * @generated |
| 2270 | */ | 2768 | */ |
| 2271 | EReference getGlobalRelationInterpretation_SourceMultiplicity(); | 2769 | EReference getAssertion_Range(); |
| 2272 | 2770 | ||
| 2273 | /** | 2771 | /** |
| 2274 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}'. | 2772 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Disjunction <em>Disjunction</em>}'. |
| 2275 | * <!-- begin-user-doc --> | 2773 | * <!-- begin-user-doc --> |
| 2276 | * <!-- end-user-doc --> | 2774 | * <!-- end-user-doc --> |
| 2277 | * @return the meta object for the containment reference '<em>Source</em>'. | 2775 | * @return the meta object for class '<em>Disjunction</em>'. |
| 2278 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource() | 2776 | * @see org.eclipse.viatra.solver.language.solverLanguage.Disjunction |
| 2279 | * @see #getGlobalRelationInterpretation() | ||
| 2280 | * @generated | 2777 | * @generated |
| 2281 | */ | 2778 | */ |
| 2282 | EReference getGlobalRelationInterpretation_Source(); | 2779 | EClass getDisjunction(); |
| 2283 | 2780 | ||
| 2284 | /** | 2781 | /** |
| 2285 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}'. | 2782 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Disjunction#getChildren <em>Children</em>}'. |
| 2286 | * <!-- begin-user-doc --> | 2783 | * <!-- begin-user-doc --> |
| 2287 | * <!-- end-user-doc --> | 2784 | * <!-- end-user-doc --> |
| 2288 | * @return the meta object for the containment reference '<em>Target Multiplicity</em>'. | 2785 | * @return the meta object for the containment reference list '<em>Children</em>'. |
| 2289 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity() | 2786 | * @see org.eclipse.viatra.solver.language.solverLanguage.Disjunction#getChildren() |
| 2290 | * @see #getGlobalRelationInterpretation() | 2787 | * @see #getDisjunction() |
| 2291 | * @generated | 2788 | * @generated |
| 2292 | */ | 2789 | */ |
| 2293 | EReference getGlobalRelationInterpretation_TargetMultiplicity(); | 2790 | EReference getDisjunction_Children(); |
| 2294 | 2791 | ||
| 2295 | /** | 2792 | /** |
| 2296 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}'. | 2793 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Switch <em>Switch</em>}'. |
| 2297 | * <!-- begin-user-doc --> | 2794 | * <!-- begin-user-doc --> |
| 2298 | * <!-- end-user-doc --> | 2795 | * <!-- end-user-doc --> |
| 2299 | * @return the meta object for the containment reference '<em>Target</em>'. | 2796 | * @return the meta object for class '<em>Switch</em>'. |
| 2300 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget() | 2797 | * @see org.eclipse.viatra.solver.language.solverLanguage.Switch |
| 2301 | * @see #getGlobalRelationInterpretation() | ||
| 2302 | * @generated | 2798 | * @generated |
| 2303 | */ | 2799 | */ |
| 2304 | EReference getGlobalRelationInterpretation_Target(); | 2800 | EClass getSwitch(); |
| 2305 | 2801 | ||
| 2306 | /** | 2802 | /** |
| 2307 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition <em>Multiplicity Definition</em>}'. | 2803 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Switch#getCases <em>Cases</em>}'. |
| 2308 | * <!-- begin-user-doc --> | 2804 | * <!-- begin-user-doc --> |
| 2309 | * <!-- end-user-doc --> | 2805 | * <!-- end-user-doc --> |
| 2310 | * @return the meta object for class '<em>Multiplicity Definition</em>'. | 2806 | * @return the meta object for the containment reference list '<em>Cases</em>'. |
| 2311 | * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition | 2807 | * @see org.eclipse.viatra.solver.language.solverLanguage.Switch#getCases() |
| 2808 | * @see #getSwitch() | ||
| 2312 | * @generated | 2809 | * @generated |
| 2313 | */ | 2810 | */ |
| 2314 | EClass getMultiplicityDefinition(); | 2811 | EReference getSwitch_Cases(); |
| 2315 | 2812 | ||
| 2316 | /** | 2813 | /** |
| 2317 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}'. | 2814 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Conjunction <em>Conjunction</em>}'. |
| 2318 | * <!-- begin-user-doc --> | 2815 | * <!-- begin-user-doc --> |
| 2319 | * <!-- end-user-doc --> | 2816 | * <!-- end-user-doc --> |
| 2320 | * @return the meta object for the attribute '<em>Lower</em>'. | 2817 | * @return the meta object for class '<em>Conjunction</em>'. |
| 2321 | * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower() | 2818 | * @see org.eclipse.viatra.solver.language.solverLanguage.Conjunction |
| 2322 | * @see #getMultiplicityDefinition() | ||
| 2323 | * @generated | 2819 | * @generated |
| 2324 | */ | 2820 | */ |
| 2325 | EAttribute getMultiplicityDefinition_Lower(); | 2821 | EClass getConjunction(); |
| 2326 | 2822 | ||
| 2327 | /** | 2823 | /** |
| 2328 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}'. | 2824 | * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Conjunction#getChildren <em>Children</em>}'. |
| 2329 | * <!-- begin-user-doc --> | 2825 | * <!-- begin-user-doc --> |
| 2330 | * <!-- end-user-doc --> | 2826 | * <!-- end-user-doc --> |
| 2331 | * @return the meta object for the attribute '<em>Upper</em>'. | 2827 | * @return the meta object for the containment reference list '<em>Children</em>'. |
| 2332 | * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper() | 2828 | * @see org.eclipse.viatra.solver.language.solverLanguage.Conjunction#getChildren() |
| 2333 | * @see #getMultiplicityDefinition() | 2829 | * @see #getConjunction() |
| 2334 | * @generated | 2830 | * @generated |
| 2335 | */ | 2831 | */ |
| 2336 | EAttribute getMultiplicityDefinition_Upper(); | 2832 | EReference getConjunction_Children(); |
| 2337 | 2833 | ||
| 2338 | /** | 2834 | /** |
| 2339 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}'. | 2835 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison <em>Comparison</em>}'. |
| 2340 | * <!-- begin-user-doc --> | 2836 | * <!-- begin-user-doc --> |
| 2341 | * <!-- end-user-doc --> | 2837 | * <!-- end-user-doc --> |
| 2342 | * @return the meta object for the attribute '<em>Unlimited Upper</em>'. | 2838 | * @return the meta object for class '<em>Comparison</em>'. |
| 2343 | * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper() | 2839 | * @see org.eclipse.viatra.solver.language.solverLanguage.Comparison |
| 2344 | * @see #getMultiplicityDefinition() | ||
| 2345 | * @generated | 2840 | * @generated |
| 2346 | */ | 2841 | */ |
| 2347 | EAttribute getMultiplicityDefinition_UnlimitedUpper(); | 2842 | EClass getComparison(); |
| 2348 | 2843 | ||
| 2349 | /** | 2844 | /** |
| 2350 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue <em>Boolean True</em>}'. | 2845 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getLeft <em>Left</em>}'. |
| 2351 | * <!-- begin-user-doc --> | 2846 | * <!-- begin-user-doc --> |
| 2352 | * <!-- end-user-doc --> | 2847 | * <!-- end-user-doc --> |
| 2353 | * @return the meta object for class '<em>Boolean True</em>'. | 2848 | * @return the meta object for the containment reference '<em>Left</em>'. |
| 2354 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue | 2849 | * @see org.eclipse.viatra.solver.language.solverLanguage.Comparison#getLeft() |
| 2850 | * @see #getComparison() | ||
| 2355 | * @generated | 2851 | * @generated |
| 2356 | */ | 2852 | */ |
| 2357 | EClass getBooleanTrue(); | 2853 | EReference getComparison_Left(); |
| 2358 | 2854 | ||
| 2359 | /** | 2855 | /** |
| 2360 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse <em>Boolean False</em>}'. | 2856 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getOp <em>Op</em>}'. |
| 2361 | * <!-- begin-user-doc --> | 2857 | * <!-- begin-user-doc --> |
| 2362 | * <!-- end-user-doc --> | 2858 | * <!-- end-user-doc --> |
| 2363 | * @return the meta object for class '<em>Boolean False</em>'. | 2859 | * @return the meta object for the attribute '<em>Op</em>'. |
| 2364 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse | 2860 | * @see org.eclipse.viatra.solver.language.solverLanguage.Comparison#getOp() |
| 2861 | * @see #getComparison() | ||
| 2365 | * @generated | 2862 | * @generated |
| 2366 | */ | 2863 | */ |
| 2367 | EClass getBooleanFalse(); | 2864 | EAttribute getComparison_Op(); |
| 2368 | 2865 | ||
| 2369 | /** | 2866 | /** |
| 2370 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.True <em>True</em>}'. | 2867 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison#getRight <em>Right</em>}'. |
| 2371 | * <!-- begin-user-doc --> | 2868 | * <!-- begin-user-doc --> |
| 2372 | * <!-- end-user-doc --> | 2869 | * <!-- end-user-doc --> |
| 2373 | * @return the meta object for class '<em>True</em>'. | 2870 | * @return the meta object for the containment reference '<em>Right</em>'. |
| 2374 | * @see org.eclipse.viatra.solver.language.solverLanguage.True | 2871 | * @see org.eclipse.viatra.solver.language.solverLanguage.Comparison#getRight() |
| 2872 | * @see #getComparison() | ||
| 2375 | * @generated | 2873 | * @generated |
| 2376 | */ | 2874 | */ |
| 2377 | EClass getTrue(); | 2875 | EReference getComparison_Right(); |
| 2378 | 2876 | ||
| 2379 | /** | 2877 | /** |
| 2380 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.False <em>False</em>}'. | 2878 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression <em>Binary Expression</em>}'. |
| 2381 | * <!-- begin-user-doc --> | 2879 | * <!-- begin-user-doc --> |
| 2382 | * <!-- end-user-doc --> | 2880 | * <!-- end-user-doc --> |
| 2383 | * @return the meta object for class '<em>False</em>'. | 2881 | * @return the meta object for class '<em>Binary Expression</em>'. |
| 2384 | * @see org.eclipse.viatra.solver.language.solverLanguage.False | 2882 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression |
| 2385 | * @generated | 2883 | * @generated |
| 2386 | */ | 2884 | */ |
| 2387 | EClass getFalse(); | 2885 | EClass getBinaryExpression(); |
| 2388 | 2886 | ||
| 2389 | /** | 2887 | /** |
| 2390 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown <em>Unknown</em>}'. | 2888 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getLeft <em>Left</em>}'. |
| 2391 | * <!-- begin-user-doc --> | 2889 | * <!-- begin-user-doc --> |
| 2392 | * <!-- end-user-doc --> | 2890 | * <!-- end-user-doc --> |
| 2393 | * @return the meta object for class '<em>Unknown</em>'. | 2891 | * @return the meta object for the containment reference '<em>Left</em>'. |
| 2394 | * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown | 2892 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getLeft() |
| 2893 | * @see #getBinaryExpression() | ||
| 2395 | * @generated | 2894 | * @generated |
| 2396 | */ | 2895 | */ |
| 2397 | EClass getUnknown(); | 2896 | EReference getBinaryExpression_Left(); |
| 2398 | 2897 | ||
| 2399 | /** | 2898 | /** |
| 2400 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error <em>Error</em>}'. | 2899 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getOp <em>Op</em>}'. |
| 2401 | * <!-- begin-user-doc --> | 2900 | * <!-- begin-user-doc --> |
| 2402 | * <!-- end-user-doc --> | 2901 | * <!-- end-user-doc --> |
| 2403 | * @return the meta object for class '<em>Error</em>'. | 2902 | * @return the meta object for the attribute '<em>Op</em>'. |
| 2404 | * @see org.eclipse.viatra.solver.language.solverLanguage.Error | 2903 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getOp() |
| 2904 | * @see #getBinaryExpression() | ||
| 2405 | * @generated | 2905 | * @generated |
| 2406 | */ | 2906 | */ |
| 2407 | EClass getError(); | 2907 | EAttribute getBinaryExpression_Op(); |
| 2408 | 2908 | ||
| 2409 | /** | 2909 | /** |
| 2410 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive <em>Positive</em>}'. | 2910 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getRight <em>Right</em>}'. |
| 2411 | * <!-- begin-user-doc --> | 2911 | * <!-- begin-user-doc --> |
| 2412 | * <!-- end-user-doc --> | 2912 | * <!-- end-user-doc --> |
| 2413 | * @return the meta object for class '<em>Positive</em>'. | 2913 | * @return the meta object for the containment reference '<em>Right</em>'. |
| 2414 | * @see org.eclipse.viatra.solver.language.solverLanguage.Positive | 2914 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression#getRight() |
| 2915 | * @see #getBinaryExpression() | ||
| 2415 | * @generated | 2916 | * @generated |
| 2416 | */ | 2917 | */ |
| 2417 | EClass getPositive(); | 2918 | EReference getBinaryExpression_Right(); |
| 2418 | 2919 | ||
| 2419 | /** | 2920 | /** |
| 2420 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative <em>Negative</em>}'. | 2921 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression <em>Unary Expression</em>}'. |
| 2421 | * <!-- begin-user-doc --> | 2922 | * <!-- begin-user-doc --> |
| 2422 | * <!-- end-user-doc --> | 2923 | * <!-- end-user-doc --> |
| 2423 | * @return the meta object for class '<em>Negative</em>'. | 2924 | * @return the meta object for class '<em>Unary Expression</em>'. |
| 2424 | * @see org.eclipse.viatra.solver.language.solverLanguage.Negative | 2925 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression |
| 2425 | * @generated | 2926 | * @generated |
| 2426 | */ | 2927 | */ |
| 2427 | EClass getNegative(); | 2928 | EClass getUnaryExpression(); |
| 2428 | 2929 | ||
| 2429 | /** | 2930 | /** |
| 2430 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure <em>Reflexive Closure</em>}'. | 2931 | * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getOp <em>Op</em>}'. |
| 2431 | * <!-- begin-user-doc --> | 2932 | * <!-- begin-user-doc --> |
| 2432 | * <!-- end-user-doc --> | 2933 | * <!-- end-user-doc --> |
| 2433 | * @return the meta object for class '<em>Reflexive Closure</em>'. | 2934 | * @return the meta object for the attribute '<em>Op</em>'. |
| 2434 | * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure | 2935 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getOp() |
| 2936 | * @see #getUnaryExpression() | ||
| 2435 | * @generated | 2937 | * @generated |
| 2436 | */ | 2938 | */ |
| 2437 | EClass getReflexiveClosure(); | 2939 | EAttribute getUnaryExpression_Op(); |
| 2438 | 2940 | ||
| 2439 | /** | 2941 | /** |
| 2440 | * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure <em>Irreflexive Closure</em>}'. | 2942 | * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getBody <em>Body</em>}'. |
| 2441 | * <!-- begin-user-doc --> | 2943 | * <!-- begin-user-doc --> |
| 2442 | * <!-- end-user-doc --> | 2944 | * <!-- end-user-doc --> |
| 2443 | * @return the meta object for class '<em>Irreflexive Closure</em>'. | 2945 | * @return the meta object for the containment reference '<em>Body</em>'. |
| 2444 | * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure | 2946 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getBody() |
| 2947 | * @see #getUnaryExpression() | ||
| 2445 | * @generated | 2948 | * @generated |
| 2446 | */ | 2949 | */ |
| 2447 | EClass getIrreflexiveClosure(); | 2950 | EReference getUnaryExpression_Body(); |
| 2951 | |||
| 2952 | /** | ||
| 2953 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricType <em>Metric Type</em>}'. | ||
| 2954 | * <!-- begin-user-doc --> | ||
| 2955 | * <!-- end-user-doc --> | ||
| 2956 | * @return the meta object for enum '<em>Metric Type</em>'. | ||
| 2957 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType | ||
| 2958 | * @generated | ||
| 2959 | */ | ||
| 2960 | EEnum getMetricType(); | ||
| 2961 | |||
| 2962 | /** | ||
| 2963 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator <em>Binary Operator</em>}'. | ||
| 2964 | * <!-- begin-user-doc --> | ||
| 2965 | * <!-- end-user-doc --> | ||
| 2966 | * @return the meta object for enum '<em>Binary Operator</em>'. | ||
| 2967 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator | ||
| 2968 | * @generated | ||
| 2969 | */ | ||
| 2970 | EEnum getBinaryOperator(); | ||
| 2971 | |||
| 2972 | /** | ||
| 2973 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryOp <em>Unary Op</em>}'. | ||
| 2974 | * <!-- begin-user-doc --> | ||
| 2975 | * <!-- end-user-doc --> | ||
| 2976 | * @return the meta object for enum '<em>Unary Op</em>'. | ||
| 2977 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryOp | ||
| 2978 | * @generated | ||
| 2979 | */ | ||
| 2980 | EEnum getUnaryOp(); | ||
| 2981 | |||
| 2982 | /** | ||
| 2983 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.AggregationOp <em>Aggregation Op</em>}'. | ||
| 2984 | * <!-- begin-user-doc --> | ||
| 2985 | * <!-- end-user-doc --> | ||
| 2986 | * @return the meta object for enum '<em>Aggregation Op</em>'. | ||
| 2987 | * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOp | ||
| 2988 | * @generated | ||
| 2989 | */ | ||
| 2990 | EEnum getAggregationOp(); | ||
| 2991 | |||
| 2992 | /** | ||
| 2993 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicValue <em>Logic Value</em>}'. | ||
| 2994 | * <!-- begin-user-doc --> | ||
| 2995 | * <!-- end-user-doc --> | ||
| 2996 | * @return the meta object for enum '<em>Logic Value</em>'. | ||
| 2997 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicValue | ||
| 2998 | * @generated | ||
| 2999 | */ | ||
| 3000 | EEnum getLogicValue(); | ||
| 3001 | |||
| 3002 | /** | ||
| 3003 | * Returns the meta object for enum '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind <em>Objective Kind</em>}'. | ||
| 3004 | * <!-- begin-user-doc --> | ||
| 3005 | * <!-- end-user-doc --> | ||
| 3006 | * @return the meta object for enum '<em>Objective Kind</em>'. | ||
| 3007 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind | ||
| 3008 | * @generated | ||
| 3009 | */ | ||
| 3010 | EEnum getObjectiveKind(); | ||
| 2448 | 3011 | ||
| 2449 | /** | 3012 | /** |
| 2450 | * Returns the factory that creates the instances of the model. | 3013 | * Returns the factory that creates the instances of the model. |
| @@ -2498,462 +3061,484 @@ public interface SolverLanguagePackage extends EPackage | |||
| 2498 | EClass STATEMENT = eINSTANCE.getStatement(); | 3061 | EClass STATEMENT = eINSTANCE.getStatement(); |
| 2499 | 3062 | ||
| 2500 | /** | 3063 | /** |
| 2501 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl <em>Boolean Value</em>}' class. | 3064 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl <em>Predicate Definition</em>}' class. |
| 2502 | * <!-- begin-user-doc --> | 3065 | * <!-- begin-user-doc --> |
| 2503 | * <!-- end-user-doc --> | 3066 | * <!-- end-user-doc --> |
| 2504 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl | 3067 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl |
| 2505 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue() | 3068 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateDefinition() |
| 2506 | * @generated | 3069 | * @generated |
| 2507 | */ | 3070 | */ |
| 2508 | EClass BOOLEAN_VALUE = eINSTANCE.getBooleanValue(); | 3071 | EClass PREDICATE_DEFINITION = eINSTANCE.getPredicateDefinition(); |
| 2509 | 3072 | ||
| 2510 | /** | 3073 | /** |
| 2511 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl <em>Truth Value</em>}' class. | 3074 | * The meta object literal for the '<em><b>Head</b></em>' containment reference feature. |
| 2512 | * <!-- begin-user-doc --> | 3075 | * <!-- begin-user-doc --> |
| 2513 | * <!-- end-user-doc --> | 3076 | * <!-- end-user-doc --> |
| 2514 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl | ||
| 2515 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue() | ||
| 2516 | * @generated | 3077 | * @generated |
| 2517 | */ | 3078 | */ |
| 2518 | EClass TRUTH_VALUE = eINSTANCE.getTruthValue(); | 3079 | EReference PREDICATE_DEFINITION__HEAD = eINSTANCE.getPredicateDefinition_Head(); |
| 2519 | 3080 | ||
| 2520 | /** | 3081 | /** |
| 2521 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl <em>Interpretation</em>}' class. | 3082 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2522 | * <!-- begin-user-doc --> | 3083 | * <!-- begin-user-doc --> |
| 2523 | * <!-- end-user-doc --> | 3084 | * <!-- end-user-doc --> |
| 2524 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl | ||
| 2525 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation() | ||
| 2526 | * @generated | 3085 | * @generated |
| 2527 | */ | 3086 | */ |
| 2528 | EClass INTERPRETATION = eINSTANCE.getInterpretation(); | 3087 | EReference PREDICATE_DEFINITION__BODY = eINSTANCE.getPredicateDefinition_Body(); |
| 2529 | 3088 | ||
| 2530 | /** | 3089 | /** |
| 2531 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl <em>Basic Interpretation</em>}' class. | 3090 | * The meta object literal for the '<em><b>Functional</b></em>' attribute feature. |
| 2532 | * <!-- begin-user-doc --> | 3091 | * <!-- begin-user-doc --> |
| 2533 | * <!-- end-user-doc --> | 3092 | * <!-- end-user-doc --> |
| 2534 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl | ||
| 2535 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation() | ||
| 2536 | * @generated | 3093 | * @generated |
| 2537 | */ | 3094 | */ |
| 2538 | EClass BASIC_INTERPRETATION = eINSTANCE.getBasicInterpretation(); | 3095 | EAttribute PREDICATE_DEFINITION__FUNCTIONAL = eINSTANCE.getPredicateDefinition_Functional(); |
| 2539 | 3096 | ||
| 2540 | /** | 3097 | /** |
| 2541 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3098 | * The meta object literal for the '<em><b>Error</b></em>' attribute feature. |
| 2542 | * <!-- begin-user-doc --> | 3099 | * <!-- begin-user-doc --> |
| 2543 | * <!-- end-user-doc --> | 3100 | * <!-- end-user-doc --> |
| 2544 | * @generated | 3101 | * @generated |
| 2545 | */ | 3102 | */ |
| 2546 | EReference BASIC_INTERPRETATION__SYMBOL = eINSTANCE.getBasicInterpretation_Symbol(); | 3103 | EAttribute PREDICATE_DEFINITION__ERROR = eINSTANCE.getPredicateDefinition_Error(); |
| 2547 | 3104 | ||
| 2548 | /** | 3105 | /** |
| 2549 | * The meta object literal for the '<em><b>Objects</b></em>' containment reference list feature. | 3106 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl <em>Unnamed Error Prediate Definition</em>}' class. |
| 2550 | * <!-- begin-user-doc --> | 3107 | * <!-- begin-user-doc --> |
| 2551 | * <!-- end-user-doc --> | 3108 | * <!-- end-user-doc --> |
| 3109 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl | ||
| 3110 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedErrorPrediateDefinition() | ||
| 2552 | * @generated | 3111 | * @generated |
| 2553 | */ | 3112 | */ |
| 2554 | EReference BASIC_INTERPRETATION__OBJECTS = eINSTANCE.getBasicInterpretation_Objects(); | 3113 | EClass UNNAMED_ERROR_PREDIATE_DEFINITION = eINSTANCE.getUnnamedErrorPrediateDefinition(); |
| 2555 | 3114 | ||
| 2556 | /** | 3115 | /** |
| 2557 | * The meta object literal for the '<em><b>Value</b></em>' containment reference feature. | 3116 | * The meta object literal for the '<em><b>Argument List</b></em>' containment reference feature. |
| 2558 | * <!-- begin-user-doc --> | 3117 | * <!-- begin-user-doc --> |
| 2559 | * <!-- end-user-doc --> | 3118 | * <!-- end-user-doc --> |
| 2560 | * @generated | 3119 | * @generated |
| 2561 | */ | 3120 | */ |
| 2562 | EReference BASIC_INTERPRETATION__VALUE = eINSTANCE.getBasicInterpretation_Value(); | 3121 | EReference UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST = eINSTANCE.getUnnamedErrorPrediateDefinition_ArgumentList(); |
| 2563 | 3122 | ||
| 2564 | /** | 3123 | /** |
| 2565 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl <em>Symbol</em>}' class. | 3124 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2566 | * <!-- begin-user-doc --> | 3125 | * <!-- begin-user-doc --> |
| 2567 | * <!-- end-user-doc --> | 3126 | * <!-- end-user-doc --> |
| 2568 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl | ||
| 2569 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol() | ||
| 2570 | * @generated | 3127 | * @generated |
| 2571 | */ | 3128 | */ |
| 2572 | EClass SYMBOL = eINSTANCE.getSymbol(); | 3129 | EReference UNNAMED_ERROR_PREDIATE_DEFINITION__BODY = eINSTANCE.getUnnamedErrorPrediateDefinition_Body(); |
| 2573 | 3130 | ||
| 2574 | /** | 3131 | /** |
| 2575 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl <em>Model Symbol</em>}' class. | 3132 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl <em>Default Definition</em>}' class. |
| 2576 | * <!-- begin-user-doc --> | 3133 | * <!-- begin-user-doc --> |
| 2577 | * <!-- end-user-doc --> | 3134 | * <!-- end-user-doc --> |
| 2578 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl | 3135 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl |
| 2579 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol() | 3136 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultDefinition() |
| 2580 | * @generated | 3137 | * @generated |
| 2581 | */ | 3138 | */ |
| 2582 | EClass MODEL_SYMBOL = eINSTANCE.getModelSymbol(); | 3139 | EClass DEFAULT_DEFINITION = eINSTANCE.getDefaultDefinition(); |
| 2583 | 3140 | ||
| 2584 | /** | 3141 | /** |
| 2585 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. | 3142 | * The meta object literal for the '<em><b>Head</b></em>' containment reference feature. |
| 2586 | * <!-- begin-user-doc --> | 3143 | * <!-- begin-user-doc --> |
| 2587 | * <!-- end-user-doc --> | 3144 | * <!-- end-user-doc --> |
| 2588 | * @generated | 3145 | * @generated |
| 2589 | */ | 3146 | */ |
| 2590 | EAttribute MODEL_SYMBOL__NAME = eINSTANCE.getModelSymbol_Name(); | 3147 | EReference DEFAULT_DEFINITION__HEAD = eINSTANCE.getDefaultDefinition_Head(); |
| 2591 | 3148 | ||
| 2592 | /** | 3149 | /** |
| 2593 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl <em>Partiality Symbol</em>}' class. | 3150 | * The meta object literal for the '<em><b>Range</b></em>' containment reference feature. |
| 2594 | * <!-- begin-user-doc --> | 3151 | * <!-- begin-user-doc --> |
| 2595 | * <!-- end-user-doc --> | 3152 | * <!-- end-user-doc --> |
| 2596 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl | ||
| 2597 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol() | ||
| 2598 | * @generated | 3153 | * @generated |
| 2599 | */ | 3154 | */ |
| 2600 | EClass PARTIALITY_SYMBOL = eINSTANCE.getPartialitySymbol(); | 3155 | EReference DEFAULT_DEFINITION__RANGE = eINSTANCE.getDefaultDefinition_Range(); |
| 2601 | 3156 | ||
| 2602 | /** | 3157 | /** |
| 2603 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl <em>Exist Symbol</em>}' class. | 3158 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternPredicateDefinitionImpl <em>Extern Predicate Definition</em>}' class. |
| 2604 | * <!-- begin-user-doc --> | 3159 | * <!-- begin-user-doc --> |
| 2605 | * <!-- end-user-doc --> | 3160 | * <!-- end-user-doc --> |
| 2606 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl | 3161 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExternPredicateDefinitionImpl |
| 2607 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol() | 3162 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExternPredicateDefinition() |
| 2608 | * @generated | 3163 | * @generated |
| 2609 | */ | 3164 | */ |
| 2610 | EClass EXIST_SYMBOL = eINSTANCE.getExistSymbol(); | 3165 | EClass EXTERN_PREDICATE_DEFINITION = eINSTANCE.getExternPredicateDefinition(); |
| 2611 | 3166 | ||
| 2612 | /** | 3167 | /** |
| 2613 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl <em>Equals Symbol</em>}' class. | 3168 | * The meta object literal for the '<em><b>Head</b></em>' containment reference feature. |
| 2614 | * <!-- begin-user-doc --> | 3169 | * <!-- begin-user-doc --> |
| 2615 | * <!-- end-user-doc --> | 3170 | * <!-- end-user-doc --> |
| 2616 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl | ||
| 2617 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol() | ||
| 2618 | * @generated | 3171 | * @generated |
| 2619 | */ | 3172 | */ |
| 2620 | EClass EQUALS_SYMBOL = eINSTANCE.getEqualsSymbol(); | 3173 | EReference EXTERN_PREDICATE_DEFINITION__HEAD = eINSTANCE.getExternPredicateDefinition_Head(); |
| 2621 | 3174 | ||
| 2622 | /** | 3175 | /** |
| 2623 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl <em>Data Symbol</em>}' class. | 3176 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl <em>Metric Definition</em>}' class. |
| 2624 | * <!-- begin-user-doc --> | 3177 | * <!-- begin-user-doc --> |
| 2625 | * <!-- end-user-doc --> | 3178 | * <!-- end-user-doc --> |
| 2626 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl | 3179 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl |
| 2627 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol() | 3180 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMetricDefinition() |
| 2628 | * @generated | 3181 | * @generated |
| 2629 | */ | 3182 | */ |
| 2630 | EClass DATA_SYMBOL = eINSTANCE.getDataSymbol(); | 3183 | EClass METRIC_DEFINITION = eINSTANCE.getMetricDefinition(); |
| 2631 | 3184 | ||
| 2632 | /** | 3185 | /** |
| 2633 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl <em>Boolean Symbol</em>}' class. | 3186 | * The meta object literal for the '<em><b>Head</b></em>' containment reference feature. |
| 2634 | * <!-- begin-user-doc --> | 3187 | * <!-- begin-user-doc --> |
| 2635 | * <!-- end-user-doc --> | 3188 | * <!-- end-user-doc --> |
| 2636 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl | ||
| 2637 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol() | ||
| 2638 | * @generated | 3189 | * @generated |
| 2639 | */ | 3190 | */ |
| 2640 | EClass BOOLEAN_SYMBOL = eINSTANCE.getBooleanSymbol(); | 3191 | EReference METRIC_DEFINITION__HEAD = eINSTANCE.getMetricDefinition_Head(); |
| 2641 | 3192 | ||
| 2642 | /** | 3193 | /** |
| 2643 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl <em>Integer Symbol</em>}' class. | 3194 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2644 | * <!-- begin-user-doc --> | 3195 | * <!-- begin-user-doc --> |
| 2645 | * <!-- end-user-doc --> | 3196 | * <!-- end-user-doc --> |
| 2646 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl | ||
| 2647 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol() | ||
| 2648 | * @generated | 3197 | * @generated |
| 2649 | */ | 3198 | */ |
| 2650 | EClass INTEGER_SYMBOL = eINSTANCE.getIntegerSymbol(); | 3199 | EReference METRIC_DEFINITION__BODY = eINSTANCE.getMetricDefinition_Body(); |
| 2651 | 3200 | ||
| 2652 | /** | 3201 | /** |
| 2653 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl <em>Real Symbol</em>}' class. | 3202 | * The meta object literal for the '<em><b>Type</b></em>' attribute feature. |
| 2654 | * <!-- begin-user-doc --> | 3203 | * <!-- begin-user-doc --> |
| 2655 | * <!-- end-user-doc --> | 3204 | * <!-- end-user-doc --> |
| 2656 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl | ||
| 2657 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol() | ||
| 2658 | * @generated | 3205 | * @generated |
| 2659 | */ | 3206 | */ |
| 2660 | EClass REAL_SYMBOL = eINSTANCE.getRealSymbol(); | 3207 | EAttribute METRIC_DEFINITION__TYPE = eINSTANCE.getMetricDefinition_Type(); |
| 2661 | 3208 | ||
| 2662 | /** | 3209 | /** |
| 2663 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl <em>String Symbol</em>}' class. | 3210 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl <em>Extern Metric Definition</em>}' class. |
| 2664 | * <!-- begin-user-doc --> | 3211 | * <!-- begin-user-doc --> |
| 2665 | * <!-- end-user-doc --> | 3212 | * <!-- end-user-doc --> |
| 2666 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl | 3213 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl |
| 2667 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol() | 3214 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExternMetricDefinition() |
| 2668 | * @generated | 3215 | * @generated |
| 2669 | */ | 3216 | */ |
| 2670 | EClass STRING_SYMBOL = eINSTANCE.getStringSymbol(); | 3217 | EClass EXTERN_METRIC_DEFINITION = eINSTANCE.getExternMetricDefinition(); |
| 2671 | 3218 | ||
| 2672 | /** | 3219 | /** |
| 2673 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl <em>Complex Object</em>}' class. | 3220 | * The meta object literal for the '<em><b>Type</b></em>' attribute feature. |
| 2674 | * <!-- begin-user-doc --> | 3221 | * <!-- begin-user-doc --> |
| 2675 | * <!-- end-user-doc --> | 3222 | * <!-- end-user-doc --> |
| 2676 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl | ||
| 2677 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject() | ||
| 2678 | * @generated | 3223 | * @generated |
| 2679 | */ | 3224 | */ |
| 2680 | EClass COMPLEX_OBJECT = eINSTANCE.getComplexObject(); | 3225 | EAttribute EXTERN_METRIC_DEFINITION__TYPE = eINSTANCE.getExternMetricDefinition_Type(); |
| 2681 | 3226 | ||
| 2682 | /** | 3227 | /** |
| 2683 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl <em>Object</em>}' class. | 3228 | * The meta object literal for the '<em><b>Head</b></em>' containment reference feature. |
| 2684 | * <!-- begin-user-doc --> | 3229 | * <!-- begin-user-doc --> |
| 2685 | * <!-- end-user-doc --> | 3230 | * <!-- end-user-doc --> |
| 2686 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl | ||
| 2687 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject() | ||
| 2688 | * @generated | 3231 | * @generated |
| 2689 | */ | 3232 | */ |
| 2690 | EClass OBJECT = eINSTANCE.getObject(); | 3233 | EReference EXTERN_METRIC_DEFINITION__HEAD = eINSTANCE.getExternMetricDefinition_Head(); |
| 2691 | 3234 | ||
| 2692 | /** | 3235 | /** |
| 2693 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl <em>Named Object</em>}' class. | 3236 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionImpl <em>Expression</em>}' class. |
| 2694 | * <!-- begin-user-doc --> | 3237 | * <!-- begin-user-doc --> |
| 2695 | * <!-- end-user-doc --> | 3238 | * <!-- end-user-doc --> |
| 2696 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl | 3239 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionImpl |
| 2697 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject() | 3240 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExpression() |
| 2698 | * @generated | 3241 | * @generated |
| 2699 | */ | 3242 | */ |
| 2700 | EClass NAMED_OBJECT = eINSTANCE.getNamedObject(); | 3243 | EClass EXPRESSION = eINSTANCE.getExpression(); |
| 2701 | 3244 | ||
| 2702 | /** | 3245 | /** |
| 2703 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. | 3246 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl <em>If Else</em>}' class. |
| 2704 | * <!-- begin-user-doc --> | 3247 | * <!-- begin-user-doc --> |
| 2705 | * <!-- end-user-doc --> | 3248 | * <!-- end-user-doc --> |
| 3249 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl | ||
| 3250 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIfElse() | ||
| 2706 | * @generated | 3251 | * @generated |
| 2707 | */ | 3252 | */ |
| 2708 | EAttribute NAMED_OBJECT__NAME = eINSTANCE.getNamedObject_Name(); | 3253 | EClass IF_ELSE = eINSTANCE.getIfElse(); |
| 2709 | 3254 | ||
| 2710 | /** | 3255 | /** |
| 2711 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl <em>Unnamed Object</em>}' class. | 3256 | * The meta object literal for the '<em><b>Condition</b></em>' containment reference feature. |
| 2712 | * <!-- begin-user-doc --> | 3257 | * <!-- begin-user-doc --> |
| 2713 | * <!-- end-user-doc --> | 3258 | * <!-- end-user-doc --> |
| 2714 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl | ||
| 2715 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject() | ||
| 2716 | * @generated | 3259 | * @generated |
| 2717 | */ | 3260 | */ |
| 2718 | EClass UNNAMED_OBJECT = eINSTANCE.getUnnamedObject(); | 3261 | EReference IF_ELSE__CONDITION = eINSTANCE.getIfElse_Condition(); |
| 2719 | 3262 | ||
| 2720 | /** | 3263 | /** |
| 2721 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. | 3264 | * The meta object literal for the '<em><b>Then</b></em>' containment reference feature. |
| 2722 | * <!-- begin-user-doc --> | 3265 | * <!-- begin-user-doc --> |
| 2723 | * <!-- end-user-doc --> | 3266 | * <!-- end-user-doc --> |
| 2724 | * @generated | 3267 | * @generated |
| 2725 | */ | 3268 | */ |
| 2726 | EAttribute UNNAMED_OBJECT__NAME = eINSTANCE.getUnnamedObject_Name(); | 3269 | EReference IF_ELSE__THEN = eINSTANCE.getIfElse_Then(); |
| 2727 | 3270 | ||
| 2728 | /** | 3271 | /** |
| 2729 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl <em>Data Object</em>}' class. | 3272 | * The meta object literal for the '<em><b>Else</b></em>' containment reference feature. |
| 2730 | * <!-- begin-user-doc --> | 3273 | * <!-- begin-user-doc --> |
| 2731 | * <!-- end-user-doc --> | 3274 | * <!-- end-user-doc --> |
| 2732 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl | ||
| 2733 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject() | ||
| 2734 | * @generated | 3275 | * @generated |
| 2735 | */ | 3276 | */ |
| 2736 | EClass DATA_OBJECT = eINSTANCE.getDataObject(); | 3277 | EReference IF_ELSE__ELSE = eINSTANCE.getIfElse_Else(); |
| 2737 | 3278 | ||
| 2738 | /** | 3279 | /** |
| 2739 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl <em>Boolean Object</em>}' class. | 3280 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl <em>Case</em>}' class. |
| 2740 | * <!-- begin-user-doc --> | 3281 | * <!-- begin-user-doc --> |
| 2741 | * <!-- end-user-doc --> | 3282 | * <!-- end-user-doc --> |
| 2742 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl | 3283 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl |
| 2743 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject() | 3284 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCase() |
| 2744 | * @generated | 3285 | * @generated |
| 2745 | */ | 3286 | */ |
| 2746 | EClass BOOLEAN_OBJECT = eINSTANCE.getBooleanObject(); | 3287 | EClass CASE = eINSTANCE.getCase(); |
| 2747 | 3288 | ||
| 2748 | /** | 3289 | /** |
| 2749 | * The meta object literal for the '<em><b>Value</b></em>' containment reference feature. | 3290 | * The meta object literal for the '<em><b>Condition</b></em>' containment reference feature. |
| 2750 | * <!-- begin-user-doc --> | 3291 | * <!-- begin-user-doc --> |
| 2751 | * <!-- end-user-doc --> | 3292 | * <!-- end-user-doc --> |
| 2752 | * @generated | 3293 | * @generated |
| 2753 | */ | 3294 | */ |
| 2754 | EReference BOOLEAN_OBJECT__VALUE = eINSTANCE.getBooleanObject_Value(); | 3295 | EReference CASE__CONDITION = eINSTANCE.getCase_Condition(); |
| 2755 | 3296 | ||
| 2756 | /** | 3297 | /** |
| 2757 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl <em>Int Object</em>}' class. | 3298 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2758 | * <!-- begin-user-doc --> | 3299 | * <!-- begin-user-doc --> |
| 2759 | * <!-- end-user-doc --> | 3300 | * <!-- end-user-doc --> |
| 2760 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl | ||
| 2761 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject() | ||
| 2762 | * @generated | 3301 | * @generated |
| 2763 | */ | 3302 | */ |
| 2764 | EClass INT_OBJECT = eINSTANCE.getIntObject(); | 3303 | EReference CASE__BODY = eINSTANCE.getCase_Body(); |
| 2765 | 3304 | ||
| 2766 | /** | 3305 | /** |
| 2767 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. | 3306 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CountImpl <em>Count</em>}' class. |
| 2768 | * <!-- begin-user-doc --> | 3307 | * <!-- begin-user-doc --> |
| 2769 | * <!-- end-user-doc --> | 3308 | * <!-- end-user-doc --> |
| 3309 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CountImpl | ||
| 3310 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCount() | ||
| 2770 | * @generated | 3311 | * @generated |
| 2771 | */ | 3312 | */ |
| 2772 | EAttribute INT_OBJECT__VALUE = eINSTANCE.getIntObject_Value(); | 3313 | EClass COUNT = eINSTANCE.getCount(); |
| 2773 | 3314 | ||
| 2774 | /** | 3315 | /** |
| 2775 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl <em>Real Object</em>}' class. | 3316 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2776 | * <!-- begin-user-doc --> | 3317 | * <!-- begin-user-doc --> |
| 2777 | * <!-- end-user-doc --> | 3318 | * <!-- end-user-doc --> |
| 2778 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl | ||
| 2779 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject() | ||
| 2780 | * @generated | 3319 | * @generated |
| 2781 | */ | 3320 | */ |
| 2782 | EClass REAL_OBJECT = eINSTANCE.getRealObject(); | 3321 | EReference COUNT__BODY = eINSTANCE.getCount_Body(); |
| 2783 | 3322 | ||
| 2784 | /** | 3323 | /** |
| 2785 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. | 3324 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl <em>Aggregation</em>}' class. |
| 2786 | * <!-- begin-user-doc --> | 3325 | * <!-- begin-user-doc --> |
| 2787 | * <!-- end-user-doc --> | 3326 | * <!-- end-user-doc --> |
| 3327 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl | ||
| 3328 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAggregation() | ||
| 2788 | * @generated | 3329 | * @generated |
| 2789 | */ | 3330 | */ |
| 2790 | EAttribute REAL_OBJECT__VALUE = eINSTANCE.getRealObject_Value(); | 3331 | EClass AGGREGATION = eINSTANCE.getAggregation(); |
| 2791 | 3332 | ||
| 2792 | /** | 3333 | /** |
| 2793 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl <em>String Object</em>}' class. | 3334 | * The meta object literal for the '<em><b>Op</b></em>' attribute feature. |
| 2794 | * <!-- begin-user-doc --> | 3335 | * <!-- begin-user-doc --> |
| 2795 | * <!-- end-user-doc --> | 3336 | * <!-- end-user-doc --> |
| 2796 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl | ||
| 2797 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject() | ||
| 2798 | * @generated | 3337 | * @generated |
| 2799 | */ | 3338 | */ |
| 2800 | EClass STRING_OBJECT = eINSTANCE.getStringObject(); | 3339 | EAttribute AGGREGATION__OP = eINSTANCE.getAggregation_Op(); |
| 2801 | 3340 | ||
| 2802 | /** | 3341 | /** |
| 2803 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. | 3342 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 3343 | * <!-- begin-user-doc --> | ||
| 3344 | * <!-- end-user-doc --> | ||
| 3345 | * @generated | ||
| 3346 | */ | ||
| 3347 | EReference AGGREGATION__BODY = eINSTANCE.getAggregation_Body(); | ||
| 3348 | |||
| 3349 | /** | ||
| 3350 | * The meta object literal for the '<em><b>Condition</b></em>' containment reference feature. | ||
| 3351 | * <!-- begin-user-doc --> | ||
| 3352 | * <!-- end-user-doc --> | ||
| 3353 | * @generated | ||
| 3354 | */ | ||
| 3355 | EReference AGGREGATION__CONDITION = eINSTANCE.getAggregation_Condition(); | ||
| 3356 | |||
| 3357 | /** | ||
| 3358 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl <em>Call</em>}' class. | ||
| 3359 | * <!-- begin-user-doc --> | ||
| 3360 | * <!-- end-user-doc --> | ||
| 3361 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl | ||
| 3362 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCall() | ||
| 3363 | * @generated | ||
| 3364 | */ | ||
| 3365 | EClass CALL = eINSTANCE.getCall(); | ||
| 3366 | |||
| 3367 | /** | ||
| 3368 | * The meta object literal for the '<em><b>Functor</b></em>' containment reference feature. | ||
| 3369 | * <!-- begin-user-doc --> | ||
| 3370 | * <!-- end-user-doc --> | ||
| 3371 | * @generated | ||
| 3372 | */ | ||
| 3373 | EReference CALL__FUNCTOR = eINSTANCE.getCall_Functor(); | ||
| 3374 | |||
| 3375 | /** | ||
| 3376 | * The meta object literal for the '<em><b>Transitive Closure</b></em>' attribute feature. | ||
| 2804 | * <!-- begin-user-doc --> | 3377 | * <!-- begin-user-doc --> |
| 2805 | * <!-- end-user-doc --> | 3378 | * <!-- end-user-doc --> |
| 2806 | * @generated | 3379 | * @generated |
| 2807 | */ | 3380 | */ |
| 2808 | EAttribute STRING_OBJECT__VALUE = eINSTANCE.getStringObject_Value(); | 3381 | EAttribute CALL__TRANSITIVE_CLOSURE = eINSTANCE.getCall_TransitiveClosure(); |
| 2809 | 3382 | ||
| 2810 | /** | 3383 | /** |
| 2811 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl <em>Predicate</em>}' class. | 3384 | * The meta object literal for the '<em><b>Reflexive Transitive Closure</b></em>' attribute feature. |
| 2812 | * <!-- begin-user-doc --> | 3385 | * <!-- begin-user-doc --> |
| 2813 | * <!-- end-user-doc --> | 3386 | * <!-- end-user-doc --> |
| 2814 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl | ||
| 2815 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate() | ||
| 2816 | * @generated | 3387 | * @generated |
| 2817 | */ | 3388 | */ |
| 2818 | EClass PREDICATE = eINSTANCE.getPredicate(); | 3389 | EAttribute CALL__REFLEXIVE_TRANSITIVE_CLOSURE = eINSTANCE.getCall_ReflexiveTransitiveClosure(); |
| 2819 | 3390 | ||
| 2820 | /** | 3391 | /** |
| 2821 | * The meta object literal for the '<em><b>Is Error</b></em>' attribute feature. | 3392 | * The meta object literal for the '<em><b>Argument List</b></em>' containment reference feature. |
| 2822 | * <!-- begin-user-doc --> | 3393 | * <!-- begin-user-doc --> |
| 2823 | * <!-- end-user-doc --> | 3394 | * <!-- end-user-doc --> |
| 2824 | * @generated | 3395 | * @generated |
| 2825 | */ | 3396 | */ |
| 2826 | EAttribute PREDICATE__IS_ERROR = eINSTANCE.getPredicate_IsError(); | 3397 | EReference CALL__ARGUMENT_LIST = eINSTANCE.getCall_ArgumentList(); |
| 2827 | 3398 | ||
| 2828 | /** | 3399 | /** |
| 2829 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3400 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentListImpl <em>Argument List</em>}' class. |
| 2830 | * <!-- begin-user-doc --> | 3401 | * <!-- begin-user-doc --> |
| 2831 | * <!-- end-user-doc --> | 3402 | * <!-- end-user-doc --> |
| 3403 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentListImpl | ||
| 3404 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getArgumentList() | ||
| 2832 | * @generated | 3405 | * @generated |
| 2833 | */ | 3406 | */ |
| 2834 | EReference PREDICATE__SYMBOL = eINSTANCE.getPredicate_Symbol(); | 3407 | EClass ARGUMENT_LIST = eINSTANCE.getArgumentList(); |
| 2835 | 3408 | ||
| 2836 | /** | 3409 | /** |
| 2837 | * The meta object literal for the '<em><b>Parameters</b></em>' containment reference list feature. | 3410 | * The meta object literal for the '<em><b>Arguments</b></em>' containment reference list feature. |
| 2838 | * <!-- begin-user-doc --> | 3411 | * <!-- begin-user-doc --> |
| 2839 | * <!-- end-user-doc --> | 3412 | * <!-- end-user-doc --> |
| 2840 | * @generated | 3413 | * @generated |
| 2841 | */ | 3414 | */ |
| 2842 | EReference PREDICATE__PARAMETERS = eINSTANCE.getPredicate_Parameters(); | 3415 | EReference ARGUMENT_LIST__ARGUMENTS = eINSTANCE.getArgumentList_Arguments(); |
| 2843 | 3416 | ||
| 2844 | /** | 3417 | /** |
| 2845 | * The meta object literal for the '<em><b>Bodies</b></em>' containment reference list feature. | 3418 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentImpl <em>Argument</em>}' class. |
| 2846 | * <!-- begin-user-doc --> | 3419 | * <!-- begin-user-doc --> |
| 2847 | * <!-- end-user-doc --> | 3420 | * <!-- end-user-doc --> |
| 3421 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentImpl | ||
| 3422 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getArgument() | ||
| 2848 | * @generated | 3423 | * @generated |
| 2849 | */ | 3424 | */ |
| 2850 | EReference PREDICATE__BODIES = eINSTANCE.getPredicate_Bodies(); | 3425 | EClass ARGUMENT = eINSTANCE.getArgument(); |
| 2851 | 3426 | ||
| 2852 | /** | 3427 | /** |
| 2853 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl <em>Parameter</em>}' class. | 3428 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionArgumentImpl <em>Expression Argument</em>}' class. |
| 2854 | * <!-- begin-user-doc --> | 3429 | * <!-- begin-user-doc --> |
| 2855 | * <!-- end-user-doc --> | 3430 | * <!-- end-user-doc --> |
| 2856 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl | 3431 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionArgumentImpl |
| 2857 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter() | 3432 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExpressionArgument() |
| 2858 | * @generated | 3433 | * @generated |
| 2859 | */ | 3434 | */ |
| 2860 | EClass PARAMETER = eINSTANCE.getParameter(); | 3435 | EClass EXPRESSION_ARGUMENT = eINSTANCE.getExpressionArgument(); |
| 2861 | 3436 | ||
| 2862 | /** | 3437 | /** |
| 2863 | * The meta object literal for the '<em><b>Variable</b></em>' containment reference feature. | 3438 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 2864 | * <!-- begin-user-doc --> | 3439 | * <!-- begin-user-doc --> |
| 2865 | * <!-- end-user-doc --> | 3440 | * <!-- end-user-doc --> |
| 2866 | * @generated | 3441 | * @generated |
| 2867 | */ | 3442 | */ |
| 2868 | EReference PARAMETER__VARIABLE = eINSTANCE.getParameter_Variable(); | 3443 | EReference EXPRESSION_ARGUMENT__BODY = eINSTANCE.getExpressionArgument_Body(); |
| 2869 | 3444 | ||
| 2870 | /** | 3445 | /** |
| 2871 | * The meta object literal for the '<em><b>Type</b></em>' containment reference feature. | 3446 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StarArgumentImpl <em>Star Argument</em>}' class. |
| 2872 | * <!-- begin-user-doc --> | 3447 | * <!-- begin-user-doc --> |
| 2873 | * <!-- end-user-doc --> | 3448 | * <!-- end-user-doc --> |
| 3449 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StarArgumentImpl | ||
| 3450 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStarArgument() | ||
| 2874 | * @generated | 3451 | * @generated |
| 2875 | */ | 3452 | */ |
| 2876 | EReference PARAMETER__TYPE = eINSTANCE.getParameter_Type(); | 3453 | EClass STAR_ARGUMENT = eINSTANCE.getStarArgument(); |
| 2877 | 3454 | ||
| 2878 | /** | 3455 | /** |
| 2879 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl <em>Pattern Body</em>}' class. | 3456 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl <em>Typed Argument</em>}' class. |
| 2880 | * <!-- begin-user-doc --> | 3457 | * <!-- begin-user-doc --> |
| 2881 | * <!-- end-user-doc --> | 3458 | * <!-- end-user-doc --> |
| 2882 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl | 3459 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl |
| 2883 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody() | 3460 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTypedArgument() |
| 2884 | * @generated | 3461 | * @generated |
| 2885 | */ | 3462 | */ |
| 2886 | EClass PATTERN_BODY = eINSTANCE.getPatternBody(); | 3463 | EClass TYPED_ARGUMENT = eINSTANCE.getTypedArgument(); |
| 2887 | 3464 | ||
| 2888 | /** | 3465 | /** |
| 2889 | * The meta object literal for the '<em><b>Constraints</b></em>' containment reference list feature. | 3466 | * The meta object literal for the '<em><b>Type</b></em>' reference feature. |
| 2890 | * <!-- begin-user-doc --> | 3467 | * <!-- begin-user-doc --> |
| 2891 | * <!-- end-user-doc --> | 3468 | * <!-- end-user-doc --> |
| 2892 | * @generated | 3469 | * @generated |
| 2893 | */ | 3470 | */ |
| 2894 | EReference PATTERN_BODY__CONSTRAINTS = eINSTANCE.getPatternBody_Constraints(); | 3471 | EReference TYPED_ARGUMENT__TYPE = eINSTANCE.getTypedArgument_Type(); |
| 2895 | 3472 | ||
| 2896 | /** | 3473 | /** |
| 2897 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl <em>Polarity</em>}' class. | 3474 | * The meta object literal for the '<em><b>Variable</b></em>' reference feature. |
| 2898 | * <!-- begin-user-doc --> | 3475 | * <!-- begin-user-doc --> |
| 2899 | * <!-- end-user-doc --> | 3476 | * <!-- end-user-doc --> |
| 2900 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl | ||
| 2901 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity() | ||
| 2902 | * @generated | 3477 | * @generated |
| 2903 | */ | 3478 | */ |
| 2904 | EClass POLARITY = eINSTANCE.getPolarity(); | 3479 | EReference TYPED_ARGUMENT__VARIABLE = eINSTANCE.getTypedArgument_Variable(); |
| 2905 | 3480 | ||
| 2906 | /** | 3481 | /** |
| 2907 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl <em>Constraint</em>}' class. | 3482 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedStarArgumentImpl <em>Typed Star Argument</em>}' class. |
| 2908 | * <!-- begin-user-doc --> | 3483 | * <!-- begin-user-doc --> |
| 2909 | * <!-- end-user-doc --> | 3484 | * <!-- end-user-doc --> |
| 2910 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl | 3485 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TypedStarArgumentImpl |
| 2911 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint() | 3486 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTypedStarArgument() |
| 2912 | * @generated | 3487 | * @generated |
| 2913 | */ | 3488 | */ |
| 2914 | EClass CONSTRAINT = eINSTANCE.getConstraint(); | 3489 | EClass TYPED_STAR_ARGUMENT = eINSTANCE.getTypedStarArgument(); |
| 2915 | 3490 | ||
| 2916 | /** | 3491 | /** |
| 2917 | * The meta object literal for the '<em><b>Polarity</b></em>' containment reference feature. | 3492 | * The meta object literal for the '<em><b>Type</b></em>' reference feature. |
| 2918 | * <!-- begin-user-doc --> | 3493 | * <!-- begin-user-doc --> |
| 2919 | * <!-- end-user-doc --> | 3494 | * <!-- end-user-doc --> |
| 2920 | * @generated | 3495 | * @generated |
| 2921 | */ | 3496 | */ |
| 2922 | EReference CONSTRAINT__POLARITY = eINSTANCE.getConstraint_Polarity(); | 3497 | EReference TYPED_STAR_ARGUMENT__TYPE = eINSTANCE.getTypedStarArgument_Type(); |
| 2923 | 3498 | ||
| 2924 | /** | 3499 | /** |
| 2925 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3500 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReferenceImpl <em>Reference</em>}' class. |
| 2926 | * <!-- begin-user-doc --> | 3501 | * <!-- begin-user-doc --> |
| 2927 | * <!-- end-user-doc --> | 3502 | * <!-- end-user-doc --> |
| 3503 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReferenceImpl | ||
| 3504 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReference() | ||
| 2928 | * @generated | 3505 | * @generated |
| 2929 | */ | 3506 | */ |
| 2930 | EReference CONSTRAINT__SYMBOL = eINSTANCE.getConstraint_Symbol(); | 3507 | EClass REFERENCE = eINSTANCE.getReference(); |
| 2931 | 3508 | ||
| 2932 | /** | 3509 | /** |
| 2933 | * The meta object literal for the '<em><b>Params</b></em>' containment reference list feature. | 3510 | * The meta object literal for the '<em><b>Referred</b></em>' reference feature. |
| 2934 | * <!-- begin-user-doc --> | 3511 | * <!-- begin-user-doc --> |
| 2935 | * <!-- end-user-doc --> | 3512 | * <!-- end-user-doc --> |
| 2936 | * @generated | 3513 | * @generated |
| 2937 | */ | 3514 | */ |
| 2938 | EReference CONSTRAINT__PARAMS = eINSTANCE.getConstraint_Params(); | 3515 | EReference REFERENCE__REFERRED = eINSTANCE.getReference_Referred(); |
| 2939 | 3516 | ||
| 2940 | /** | 3517 | /** |
| 2941 | * The meta object literal for the '<em><b>Closure Type</b></em>' containment reference feature. | 3518 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl <em>Interval</em>}' class. |
| 2942 | * <!-- begin-user-doc --> | 3519 | * <!-- begin-user-doc --> |
| 2943 | * <!-- end-user-doc --> | 3520 | * <!-- end-user-doc --> |
| 3521 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl | ||
| 3522 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterval() | ||
| 2944 | * @generated | 3523 | * @generated |
| 2945 | */ | 3524 | */ |
| 2946 | EReference CONSTRAINT__CLOSURE_TYPE = eINSTANCE.getConstraint_ClosureType(); | 3525 | EClass INTERVAL = eINSTANCE.getInterval(); |
| 2947 | 3526 | ||
| 2948 | /** | 3527 | /** |
| 2949 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl <em>Closure Type</em>}' class. | 3528 | * The meta object literal for the '<em><b>Lower Bound</b></em>' containment reference feature. |
| 2950 | * <!-- begin-user-doc --> | 3529 | * <!-- begin-user-doc --> |
| 2951 | * <!-- end-user-doc --> | 3530 | * <!-- end-user-doc --> |
| 2952 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl | ||
| 2953 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType() | ||
| 2954 | * @generated | 3531 | * @generated |
| 2955 | */ | 3532 | */ |
| 2956 | EClass CLOSURE_TYPE = eINSTANCE.getClosureType(); | 3533 | EReference INTERVAL__LOWER_BOUND = eINSTANCE.getInterval_LowerBound(); |
| 3534 | |||
| 3535 | /** | ||
| 3536 | * The meta object literal for the '<em><b>Upper Bound</b></em>' containment reference feature. | ||
| 3537 | * <!-- begin-user-doc --> | ||
| 3538 | * <!-- end-user-doc --> | ||
| 3539 | * @generated | ||
| 3540 | */ | ||
| 3541 | EReference INTERVAL__UPPER_BOUND = eINSTANCE.getInterval_UpperBound(); | ||
| 2957 | 3542 | ||
| 2958 | /** | 3543 | /** |
| 2959 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class. | 3544 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class. |
| @@ -2966,88 +3551,88 @@ public interface SolverLanguagePackage extends EPackage | |||
| 2966 | EClass LITERAL = eINSTANCE.getLiteral(); | 3551 | EClass LITERAL = eINSTANCE.getLiteral(); |
| 2967 | 3552 | ||
| 2968 | /** | 3553 | /** |
| 2969 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl <em>Variable</em>}' class. | 3554 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LogicLiteralImpl <em>Logic Literal</em>}' class. |
| 2970 | * <!-- begin-user-doc --> | 3555 | * <!-- begin-user-doc --> |
| 2971 | * <!-- end-user-doc --> | 3556 | * <!-- end-user-doc --> |
| 2972 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl | 3557 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LogicLiteralImpl |
| 2973 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable() | 3558 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLogicLiteral() |
| 2974 | * @generated | 3559 | * @generated |
| 2975 | */ | 3560 | */ |
| 2976 | EClass VARIABLE = eINSTANCE.getVariable(); | 3561 | EClass LOGIC_LITERAL = eINSTANCE.getLogicLiteral(); |
| 2977 | 3562 | ||
| 2978 | /** | 3563 | /** |
| 2979 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. | 3564 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. |
| 2980 | * <!-- begin-user-doc --> | 3565 | * <!-- begin-user-doc --> |
| 2981 | * <!-- end-user-doc --> | 3566 | * <!-- end-user-doc --> |
| 2982 | * @generated | 3567 | * @generated |
| 2983 | */ | 3568 | */ |
| 2984 | EAttribute VARIABLE__NAME = eINSTANCE.getVariable_Name(); | 3569 | EAttribute LOGIC_LITERAL__VALUE = eINSTANCE.getLogicLiteral_Value(); |
| 2985 | 3570 | ||
| 2986 | /** | 3571 | /** |
| 2987 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl <em>All Instances</em>}' class. | 3572 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NumericLiteralImpl <em>Numeric Literal</em>}' class. |
| 2988 | * <!-- begin-user-doc --> | 3573 | * <!-- begin-user-doc --> |
| 2989 | * <!-- end-user-doc --> | 3574 | * <!-- end-user-doc --> |
| 2990 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl | 3575 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NumericLiteralImpl |
| 2991 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances() | 3576 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNumericLiteral() |
| 2992 | * @generated | 3577 | * @generated |
| 2993 | */ | 3578 | */ |
| 2994 | EClass ALL_INSTANCES = eINSTANCE.getAllInstances(); | 3579 | EClass NUMERIC_LITERAL = eINSTANCE.getNumericLiteral(); |
| 2995 | 3580 | ||
| 2996 | /** | 3581 | /** |
| 2997 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3582 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. |
| 2998 | * <!-- begin-user-doc --> | 3583 | * <!-- begin-user-doc --> |
| 2999 | * <!-- end-user-doc --> | 3584 | * <!-- end-user-doc --> |
| 3000 | * @generated | 3585 | * @generated |
| 3001 | */ | 3586 | */ |
| 3002 | EReference ALL_INSTANCES__SYMBOL = eINSTANCE.getAllInstances_Symbol(); | 3587 | EAttribute NUMERIC_LITERAL__VALUE = eINSTANCE.getNumericLiteral_Value(); |
| 3003 | 3588 | ||
| 3004 | /** | 3589 | /** |
| 3005 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl <em>All Objects</em>}' class. | 3590 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InfinityLiteralImpl <em>Infinity Literal</em>}' class. |
| 3006 | * <!-- begin-user-doc --> | 3591 | * <!-- begin-user-doc --> |
| 3007 | * <!-- end-user-doc --> | 3592 | * <!-- end-user-doc --> |
| 3008 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl | 3593 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InfinityLiteralImpl |
| 3009 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects() | 3594 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInfinityLiteral() |
| 3010 | * @generated | 3595 | * @generated |
| 3011 | */ | 3596 | */ |
| 3012 | EClass ALL_OBJECTS = eINSTANCE.getAllObjects(); | 3597 | EClass INFINITY_LITERAL = eINSTANCE.getInfinityLiteral(); |
| 3013 | 3598 | ||
| 3014 | /** | 3599 | /** |
| 3015 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl <em>Default Interpretation</em>}' class. | 3600 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EmptyIntervalLiteralImpl <em>Empty Interval Literal</em>}' class. |
| 3016 | * <!-- begin-user-doc --> | 3601 | * <!-- begin-user-doc --> |
| 3017 | * <!-- end-user-doc --> | 3602 | * <!-- end-user-doc --> |
| 3018 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl | 3603 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EmptyIntervalLiteralImpl |
| 3019 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation() | 3604 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEmptyIntervalLiteral() |
| 3020 | * @generated | 3605 | * @generated |
| 3021 | */ | 3606 | */ |
| 3022 | EClass DEFAULT_INTERPRETATION = eINSTANCE.getDefaultInterpretation(); | 3607 | EClass EMPTY_INTERVAL_LITERAL = eINSTANCE.getEmptyIntervalLiteral(); |
| 3023 | 3608 | ||
| 3024 | /** | 3609 | /** |
| 3025 | * The meta object literal for the '<em><b>Interpretation</b></em>' containment reference feature. | 3610 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringLiteralImpl <em>String Literal</em>}' class. |
| 3026 | * <!-- begin-user-doc --> | 3611 | * <!-- begin-user-doc --> |
| 3027 | * <!-- end-user-doc --> | 3612 | * <!-- end-user-doc --> |
| 3613 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringLiteralImpl | ||
| 3614 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringLiteral() | ||
| 3028 | * @generated | 3615 | * @generated |
| 3029 | */ | 3616 | */ |
| 3030 | EReference DEFAULT_INTERPRETATION__INTERPRETATION = eINSTANCE.getDefaultInterpretation_Interpretation(); | 3617 | EClass STRING_LITERAL = eINSTANCE.getStringLiteral(); |
| 3031 | 3618 | ||
| 3032 | /** | 3619 | /** |
| 3033 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl <em>CD Interpretation</em>}' class. | 3620 | * The meta object literal for the '<em><b>Value</b></em>' attribute feature. |
| 3034 | * <!-- begin-user-doc --> | 3621 | * <!-- begin-user-doc --> |
| 3035 | * <!-- end-user-doc --> | 3622 | * <!-- end-user-doc --> |
| 3036 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl | ||
| 3037 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation() | ||
| 3038 | * @generated | 3623 | * @generated |
| 3039 | */ | 3624 | */ |
| 3040 | EClass CD_INTERPRETATION = eINSTANCE.getCDInterpretation(); | 3625 | EAttribute STRING_LITERAL__VALUE = eINSTANCE.getStringLiteral_Value(); |
| 3041 | 3626 | ||
| 3042 | /** | 3627 | /** |
| 3043 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl <em>Class Interpretation</em>}' class. | 3628 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl <em>Class Definition</em>}' class. |
| 3044 | * <!-- begin-user-doc --> | 3629 | * <!-- begin-user-doc --> |
| 3045 | * <!-- end-user-doc --> | 3630 | * <!-- end-user-doc --> |
| 3046 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl | 3631 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl |
| 3047 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation() | 3632 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassDefinition() |
| 3048 | * @generated | 3633 | * @generated |
| 3049 | */ | 3634 | */ |
| 3050 | EClass CLASS_INTERPRETATION = eINSTANCE.getClassInterpretation(); | 3635 | EClass CLASS_DEFINITION = eINSTANCE.getClassDefinition(); |
| 3051 | 3636 | ||
| 3052 | /** | 3637 | /** |
| 3053 | * The meta object literal for the '<em><b>Abstract</b></em>' attribute feature. | 3638 | * The meta object literal for the '<em><b>Abstract</b></em>' attribute feature. |
| @@ -3055,291 +3640,503 @@ public interface SolverLanguagePackage extends EPackage | |||
| 3055 | * <!-- end-user-doc --> | 3640 | * <!-- end-user-doc --> |
| 3056 | * @generated | 3641 | * @generated |
| 3057 | */ | 3642 | */ |
| 3058 | EAttribute CLASS_INTERPRETATION__ABSTRACT = eINSTANCE.getClassInterpretation_Abstract(); | 3643 | EAttribute CLASS_DEFINITION__ABSTRACT = eINSTANCE.getClassDefinition_Abstract(); |
| 3059 | 3644 | ||
| 3060 | /** | 3645 | /** |
| 3061 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3646 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. |
| 3062 | * <!-- begin-user-doc --> | 3647 | * <!-- begin-user-doc --> |
| 3063 | * <!-- end-user-doc --> | 3648 | * <!-- end-user-doc --> |
| 3064 | * @generated | 3649 | * @generated |
| 3065 | */ | 3650 | */ |
| 3066 | EReference CLASS_INTERPRETATION__SYMBOL = eINSTANCE.getClassInterpretation_Symbol(); | 3651 | EAttribute CLASS_DEFINITION__NAME = eINSTANCE.getClassDefinition_Name(); |
| 3067 | 3652 | ||
| 3068 | /** | 3653 | /** |
| 3069 | * The meta object literal for the '<em><b>Supertypes</b></em>' containment reference list feature. | 3654 | * The meta object literal for the '<em><b>Superclasses</b></em>' reference list feature. |
| 3070 | * <!-- begin-user-doc --> | 3655 | * <!-- begin-user-doc --> |
| 3071 | * <!-- end-user-doc --> | 3656 | * <!-- end-user-doc --> |
| 3072 | * @generated | 3657 | * @generated |
| 3073 | */ | 3658 | */ |
| 3074 | EReference CLASS_INTERPRETATION__SUPERTYPES = eINSTANCE.getClassInterpretation_Supertypes(); | 3659 | EReference CLASS_DEFINITION__SUPERCLASSES = eINSTANCE.getClassDefinition_Superclasses(); |
| 3075 | 3660 | ||
| 3076 | /** | 3661 | /** |
| 3077 | * The meta object literal for the '<em><b>Fielt</b></em>' containment reference list feature. | 3662 | * The meta object literal for the '<em><b>Members</b></em>' containment reference list feature. |
| 3078 | * <!-- begin-user-doc --> | 3663 | * <!-- begin-user-doc --> |
| 3079 | * <!-- end-user-doc --> | 3664 | * <!-- end-user-doc --> |
| 3080 | * @generated | 3665 | * @generated |
| 3081 | */ | 3666 | */ |
| 3082 | EReference CLASS_INTERPRETATION__FIELT = eINSTANCE.getClassInterpretation_Fielt(); | 3667 | EReference CLASS_DEFINITION__MEMBERS = eINSTANCE.getClassDefinition_Members(); |
| 3083 | 3668 | ||
| 3084 | /** | 3669 | /** |
| 3085 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl <em>Enum Interpretation</em>}' class. | 3670 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl <em>Member Definition</em>}' class. |
| 3086 | * <!-- begin-user-doc --> | 3671 | * <!-- begin-user-doc --> |
| 3087 | * <!-- end-user-doc --> | 3672 | * <!-- end-user-doc --> |
| 3088 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl | 3673 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl |
| 3089 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation() | 3674 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMemberDefinition() |
| 3090 | * @generated | 3675 | * @generated |
| 3091 | */ | 3676 | */ |
| 3092 | EClass ENUM_INTERPRETATION = eINSTANCE.getEnumInterpretation(); | 3677 | EClass MEMBER_DEFINITION = eINSTANCE.getMemberDefinition(); |
| 3093 | 3678 | ||
| 3094 | /** | 3679 | /** |
| 3095 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3680 | * The meta object literal for the '<em><b>Containment</b></em>' attribute feature. |
| 3096 | * <!-- begin-user-doc --> | 3681 | * <!-- begin-user-doc --> |
| 3097 | * <!-- end-user-doc --> | 3682 | * <!-- end-user-doc --> |
| 3098 | * @generated | 3683 | * @generated |
| 3099 | */ | 3684 | */ |
| 3100 | EReference ENUM_INTERPRETATION__SYMBOL = eINSTANCE.getEnumInterpretation_Symbol(); | 3685 | EAttribute MEMBER_DEFINITION__CONTAINMENT = eINSTANCE.getMemberDefinition_Containment(); |
| 3101 | 3686 | ||
| 3102 | /** | 3687 | /** |
| 3103 | * The meta object literal for the '<em><b>Objects</b></em>' containment reference list feature. | 3688 | * The meta object literal for the '<em><b>Type</b></em>' reference feature. |
| 3104 | * <!-- begin-user-doc --> | 3689 | * <!-- begin-user-doc --> |
| 3105 | * <!-- end-user-doc --> | 3690 | * <!-- end-user-doc --> |
| 3106 | * @generated | 3691 | * @generated |
| 3107 | */ | 3692 | */ |
| 3108 | EReference ENUM_INTERPRETATION__OBJECTS = eINSTANCE.getEnumInterpretation_Objects(); | 3693 | EReference MEMBER_DEFINITION__TYPE = eINSTANCE.getMemberDefinition_Type(); |
| 3109 | 3694 | ||
| 3110 | /** | 3695 | /** |
| 3111 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl <em>Field Relation Interpretation</em>}' class. | 3696 | * The meta object literal for the '<em><b>Multiplicity</b></em>' containment reference feature. |
| 3112 | * <!-- begin-user-doc --> | 3697 | * <!-- begin-user-doc --> |
| 3113 | * <!-- end-user-doc --> | 3698 | * <!-- end-user-doc --> |
| 3114 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl | ||
| 3115 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation() | ||
| 3116 | * @generated | 3699 | * @generated |
| 3117 | */ | 3700 | */ |
| 3118 | EClass FIELD_RELATION_INTERPRETATION = eINSTANCE.getFieldRelationInterpretation(); | 3701 | EReference MEMBER_DEFINITION__MULTIPLICITY = eINSTANCE.getMemberDefinition_Multiplicity(); |
| 3119 | 3702 | ||
| 3120 | /** | 3703 | /** |
| 3121 | * The meta object literal for the '<em><b>Containment</b></em>' attribute feature. | 3704 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. |
| 3122 | * <!-- begin-user-doc --> | 3705 | * <!-- begin-user-doc --> |
| 3123 | * <!-- end-user-doc --> | 3706 | * <!-- end-user-doc --> |
| 3124 | * @generated | 3707 | * @generated |
| 3125 | */ | 3708 | */ |
| 3126 | EAttribute FIELD_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getFieldRelationInterpretation_Containment(); | 3709 | EAttribute MEMBER_DEFINITION__NAME = eINSTANCE.getMemberDefinition_Name(); |
| 3127 | 3710 | ||
| 3128 | /** | 3711 | /** |
| 3129 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3712 | * The meta object literal for the '<em><b>Opposite</b></em>' reference feature. |
| 3130 | * <!-- begin-user-doc --> | 3713 | * <!-- begin-user-doc --> |
| 3131 | * <!-- end-user-doc --> | 3714 | * <!-- end-user-doc --> |
| 3132 | * @generated | 3715 | * @generated |
| 3133 | */ | 3716 | */ |
| 3134 | EReference FIELD_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getFieldRelationInterpretation_Symbol(); | 3717 | EReference MEMBER_DEFINITION__OPPOSITE = eINSTANCE.getMemberDefinition_Opposite(); |
| 3135 | 3718 | ||
| 3136 | /** | 3719 | /** |
| 3137 | * The meta object literal for the '<em><b>Multiplicity</b></em>' containment reference feature. | 3720 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityImpl <em>Multiplicity</em>}' class. |
| 3138 | * <!-- begin-user-doc --> | 3721 | * <!-- begin-user-doc --> |
| 3139 | * <!-- end-user-doc --> | 3722 | * <!-- end-user-doc --> |
| 3723 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityImpl | ||
| 3724 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicity() | ||
| 3140 | * @generated | 3725 | * @generated |
| 3141 | */ | 3726 | */ |
| 3142 | EReference FIELD_RELATION_INTERPRETATION__MULTIPLICITY = eINSTANCE.getFieldRelationInterpretation_Multiplicity(); | 3727 | EClass MULTIPLICITY = eINSTANCE.getMultiplicity(); |
| 3143 | 3728 | ||
| 3144 | /** | 3729 | /** |
| 3145 | * The meta object literal for the '<em><b>Target</b></em>' containment reference feature. | 3730 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ManyMultiplicityImpl <em>Many Multiplicity</em>}' class. |
| 3146 | * <!-- begin-user-doc --> | 3731 | * <!-- begin-user-doc --> |
| 3147 | * <!-- end-user-doc --> | 3732 | * <!-- end-user-doc --> |
| 3733 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ManyMultiplicityImpl | ||
| 3734 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getManyMultiplicity() | ||
| 3148 | * @generated | 3735 | * @generated |
| 3149 | */ | 3736 | */ |
| 3150 | EReference FIELD_RELATION_INTERPRETATION__TARGET = eINSTANCE.getFieldRelationInterpretation_Target(); | 3737 | EClass MANY_MULTIPLICITY = eINSTANCE.getManyMultiplicity(); |
| 3151 | 3738 | ||
| 3152 | /** | 3739 | /** |
| 3153 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl <em>Global Relation Interpretation</em>}' class. | 3740 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactMultiplicityImpl <em>Exact Multiplicity</em>}' class. |
| 3154 | * <!-- begin-user-doc --> | 3741 | * <!-- begin-user-doc --> |
| 3155 | * <!-- end-user-doc --> | 3742 | * <!-- end-user-doc --> |
| 3156 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl | 3743 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExactMultiplicityImpl |
| 3157 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation() | 3744 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExactMultiplicity() |
| 3158 | * @generated | 3745 | * @generated |
| 3159 | */ | 3746 | */ |
| 3160 | EClass GLOBAL_RELATION_INTERPRETATION = eINSTANCE.getGlobalRelationInterpretation(); | 3747 | EClass EXACT_MULTIPLICITY = eINSTANCE.getExactMultiplicity(); |
| 3161 | 3748 | ||
| 3162 | /** | 3749 | /** |
| 3163 | * The meta object literal for the '<em><b>Containment</b></em>' attribute feature. | 3750 | * The meta object literal for the '<em><b>Multiplicity</b></em>' attribute feature. |
| 3751 | * <!-- begin-user-doc --> | ||
| 3752 | * <!-- end-user-doc --> | ||
| 3753 | * @generated | ||
| 3754 | */ | ||
| 3755 | EAttribute EXACT_MULTIPLICITY__MULTIPLICITY = eINSTANCE.getExactMultiplicity_Multiplicity(); | ||
| 3756 | |||
| 3757 | /** | ||
| 3758 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl <em>Bounded Multiplicity</em>}' class. | ||
| 3759 | * <!-- begin-user-doc --> | ||
| 3760 | * <!-- end-user-doc --> | ||
| 3761 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl | ||
| 3762 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBoundedMultiplicity() | ||
| 3763 | * @generated | ||
| 3764 | */ | ||
| 3765 | EClass BOUNDED_MULTIPLICITY = eINSTANCE.getBoundedMultiplicity(); | ||
| 3766 | |||
| 3767 | /** | ||
| 3768 | * The meta object literal for the '<em><b>Lower Bound</b></em>' attribute feature. | ||
| 3769 | * <!-- begin-user-doc --> | ||
| 3770 | * <!-- end-user-doc --> | ||
| 3771 | * @generated | ||
| 3772 | */ | ||
| 3773 | EAttribute BOUNDED_MULTIPLICITY__LOWER_BOUND = eINSTANCE.getBoundedMultiplicity_LowerBound(); | ||
| 3774 | |||
| 3775 | /** | ||
| 3776 | * The meta object literal for the '<em><b>Upper Bound</b></em>' attribute feature. | ||
| 3777 | * <!-- begin-user-doc --> | ||
| 3778 | * <!-- end-user-doc --> | ||
| 3779 | * @generated | ||
| 3780 | */ | ||
| 3781 | EAttribute BOUNDED_MULTIPLICITY__UPPER_BOUND = eINSTANCE.getBoundedMultiplicity_UpperBound(); | ||
| 3782 | |||
| 3783 | /** | ||
| 3784 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ScopeDefinitionImpl <em>Scope Definition</em>}' class. | ||
| 3785 | * <!-- begin-user-doc --> | ||
| 3786 | * <!-- end-user-doc --> | ||
| 3787 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ScopeDefinitionImpl | ||
| 3788 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getScopeDefinition() | ||
| 3789 | * @generated | ||
| 3790 | */ | ||
| 3791 | EClass SCOPE_DEFINITION = eINSTANCE.getScopeDefinition(); | ||
| 3792 | |||
| 3793 | /** | ||
| 3794 | * The meta object literal for the '<em><b>Type</b></em>' reference feature. | ||
| 3795 | * <!-- begin-user-doc --> | ||
| 3796 | * <!-- end-user-doc --> | ||
| 3797 | * @generated | ||
| 3798 | */ | ||
| 3799 | EReference SCOPE_DEFINITION__TYPE = eINSTANCE.getScopeDefinition_Type(); | ||
| 3800 | |||
| 3801 | /** | ||
| 3802 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactScopeDefinitionImpl <em>Exact Scope Definition</em>}' class. | ||
| 3803 | * <!-- begin-user-doc --> | ||
| 3804 | * <!-- end-user-doc --> | ||
| 3805 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExactScopeDefinitionImpl | ||
| 3806 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExactScopeDefinition() | ||
| 3807 | * @generated | ||
| 3808 | */ | ||
| 3809 | EClass EXACT_SCOPE_DEFINITION = eINSTANCE.getExactScopeDefinition(); | ||
| 3810 | |||
| 3811 | /** | ||
| 3812 | * The meta object literal for the '<em><b>Exact Scope</b></em>' attribute feature. | ||
| 3813 | * <!-- begin-user-doc --> | ||
| 3814 | * <!-- end-user-doc --> | ||
| 3815 | * @generated | ||
| 3816 | */ | ||
| 3817 | EAttribute EXACT_SCOPE_DEFINITION__EXACT_SCOPE = eINSTANCE.getExactScopeDefinition_ExactScope(); | ||
| 3818 | |||
| 3819 | /** | ||
| 3820 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl <em>Bounded Scope Definition</em>}' class. | ||
| 3821 | * <!-- begin-user-doc --> | ||
| 3822 | * <!-- end-user-doc --> | ||
| 3823 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl | ||
| 3824 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBoundedScopeDefinition() | ||
| 3825 | * @generated | ||
| 3826 | */ | ||
| 3827 | EClass BOUNDED_SCOPE_DEFINITION = eINSTANCE.getBoundedScopeDefinition(); | ||
| 3828 | |||
| 3829 | /** | ||
| 3830 | * The meta object literal for the '<em><b>Lower Bound</b></em>' attribute feature. | ||
| 3831 | * <!-- begin-user-doc --> | ||
| 3832 | * <!-- end-user-doc --> | ||
| 3833 | * @generated | ||
| 3834 | */ | ||
| 3835 | EAttribute BOUNDED_SCOPE_DEFINITION__LOWER_BOUND = eINSTANCE.getBoundedScopeDefinition_LowerBound(); | ||
| 3836 | |||
| 3837 | /** | ||
| 3838 | * The meta object literal for the '<em><b>Upper Bound</b></em>' attribute feature. | ||
| 3839 | * <!-- begin-user-doc --> | ||
| 3840 | * <!-- end-user-doc --> | ||
| 3841 | * @generated | ||
| 3842 | */ | ||
| 3843 | EAttribute BOUNDED_SCOPE_DEFINITION__UPPER_BOUND = eINSTANCE.getBoundedScopeDefinition_UpperBound(); | ||
| 3844 | |||
| 3845 | /** | ||
| 3846 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LowerBoundedScopeDefinitionImpl <em>Lower Bounded Scope Definition</em>}' class. | ||
| 3847 | * <!-- begin-user-doc --> | ||
| 3848 | * <!-- end-user-doc --> | ||
| 3849 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LowerBoundedScopeDefinitionImpl | ||
| 3850 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLowerBoundedScopeDefinition() | ||
| 3851 | * @generated | ||
| 3852 | */ | ||
| 3853 | EClass LOWER_BOUNDED_SCOPE_DEFINITION = eINSTANCE.getLowerBoundedScopeDefinition(); | ||
| 3854 | |||
| 3855 | /** | ||
| 3856 | * The meta object literal for the '<em><b>Lower Bound</b></em>' attribute feature. | ||
| 3857 | * <!-- begin-user-doc --> | ||
| 3858 | * <!-- end-user-doc --> | ||
| 3859 | * @generated | ||
| 3860 | */ | ||
| 3861 | EAttribute LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND = eINSTANCE.getLowerBoundedScopeDefinition_LowerBound(); | ||
| 3862 | |||
| 3863 | /** | ||
| 3864 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl <em>Objective Definition</em>}' class. | ||
| 3865 | * <!-- begin-user-doc --> | ||
| 3866 | * <!-- end-user-doc --> | ||
| 3867 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl | ||
| 3868 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObjectiveDefinition() | ||
| 3869 | * @generated | ||
| 3870 | */ | ||
| 3871 | EClass OBJECTIVE_DEFINITION = eINSTANCE.getObjectiveDefinition(); | ||
| 3872 | |||
| 3873 | /** | ||
| 3874 | * The meta object literal for the '<em><b>Kind</b></em>' attribute feature. | ||
| 3875 | * <!-- begin-user-doc --> | ||
| 3876 | * <!-- end-user-doc --> | ||
| 3877 | * @generated | ||
| 3878 | */ | ||
| 3879 | EAttribute OBJECTIVE_DEFINITION__KIND = eINSTANCE.getObjectiveDefinition_Kind(); | ||
| 3880 | |||
| 3881 | /** | ||
| 3882 | * The meta object literal for the '<em><b>Objective</b></em>' containment reference feature. | ||
| 3883 | * <!-- begin-user-doc --> | ||
| 3884 | * <!-- end-user-doc --> | ||
| 3885 | * @generated | ||
| 3886 | */ | ||
| 3887 | EReference OBJECTIVE_DEFINITION__OBJECTIVE = eINSTANCE.getObjectiveDefinition_Objective(); | ||
| 3888 | |||
| 3889 | /** | ||
| 3890 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedElementImpl <em>Named Element</em>}' class. | ||
| 3891 | * <!-- begin-user-doc --> | ||
| 3892 | * <!-- end-user-doc --> | ||
| 3893 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedElementImpl | ||
| 3894 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedElement() | ||
| 3895 | * @generated | ||
| 3896 | */ | ||
| 3897 | EClass NAMED_ELEMENT = eINSTANCE.getNamedElement(); | ||
| 3898 | |||
| 3899 | /** | ||
| 3900 | * The meta object literal for the '<em><b>Name</b></em>' attribute feature. | ||
| 3901 | * <!-- begin-user-doc --> | ||
| 3902 | * <!-- end-user-doc --> | ||
| 3903 | * @generated | ||
| 3904 | */ | ||
| 3905 | EAttribute NAMED_ELEMENT__NAME = eINSTANCE.getNamedElement_Name(); | ||
| 3906 | |||
| 3907 | /** | ||
| 3908 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl <em>Assertion</em>}' class. | ||
| 3909 | * <!-- begin-user-doc --> | ||
| 3910 | * <!-- end-user-doc --> | ||
| 3911 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl | ||
| 3912 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAssertion() | ||
| 3913 | * @generated | ||
| 3914 | */ | ||
| 3915 | EClass ASSERTION = eINSTANCE.getAssertion(); | ||
| 3916 | |||
| 3917 | /** | ||
| 3918 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. | ||
| 3919 | * <!-- begin-user-doc --> | ||
| 3920 | * <!-- end-user-doc --> | ||
| 3921 | * @generated | ||
| 3922 | */ | ||
| 3923 | EReference ASSERTION__BODY = eINSTANCE.getAssertion_Body(); | ||
| 3924 | |||
| 3925 | /** | ||
| 3926 | * The meta object literal for the '<em><b>Range</b></em>' containment reference feature. | ||
| 3927 | * <!-- begin-user-doc --> | ||
| 3928 | * <!-- end-user-doc --> | ||
| 3929 | * @generated | ||
| 3930 | */ | ||
| 3931 | EReference ASSERTION__RANGE = eINSTANCE.getAssertion_Range(); | ||
| 3932 | |||
| 3933 | /** | ||
| 3934 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DisjunctionImpl <em>Disjunction</em>}' class. | ||
| 3935 | * <!-- begin-user-doc --> | ||
| 3936 | * <!-- end-user-doc --> | ||
| 3937 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DisjunctionImpl | ||
| 3938 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDisjunction() | ||
| 3939 | * @generated | ||
| 3940 | */ | ||
| 3941 | EClass DISJUNCTION = eINSTANCE.getDisjunction(); | ||
| 3942 | |||
| 3943 | /** | ||
| 3944 | * The meta object literal for the '<em><b>Children</b></em>' containment reference list feature. | ||
| 3945 | * <!-- begin-user-doc --> | ||
| 3946 | * <!-- end-user-doc --> | ||
| 3947 | * @generated | ||
| 3948 | */ | ||
| 3949 | EReference DISJUNCTION__CHILDREN = eINSTANCE.getDisjunction_Children(); | ||
| 3950 | |||
| 3951 | /** | ||
| 3952 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SwitchImpl <em>Switch</em>}' class. | ||
| 3953 | * <!-- begin-user-doc --> | ||
| 3954 | * <!-- end-user-doc --> | ||
| 3955 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SwitchImpl | ||
| 3956 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSwitch() | ||
| 3957 | * @generated | ||
| 3958 | */ | ||
| 3959 | EClass SWITCH = eINSTANCE.getSwitch(); | ||
| 3960 | |||
| 3961 | /** | ||
| 3962 | * The meta object literal for the '<em><b>Cases</b></em>' containment reference list feature. | ||
| 3164 | * <!-- begin-user-doc --> | 3963 | * <!-- begin-user-doc --> |
| 3165 | * <!-- end-user-doc --> | 3964 | * <!-- end-user-doc --> |
| 3166 | * @generated | 3965 | * @generated |
| 3167 | */ | 3966 | */ |
| 3168 | EAttribute GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getGlobalRelationInterpretation_Containment(); | 3967 | EReference SWITCH__CASES = eINSTANCE.getSwitch_Cases(); |
| 3169 | 3968 | ||
| 3170 | /** | 3969 | /** |
| 3171 | * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature. | 3970 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConjunctionImpl <em>Conjunction</em>}' class. |
| 3172 | * <!-- begin-user-doc --> | 3971 | * <!-- begin-user-doc --> |
| 3173 | * <!-- end-user-doc --> | 3972 | * <!-- end-user-doc --> |
| 3973 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConjunctionImpl | ||
| 3974 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConjunction() | ||
| 3174 | * @generated | 3975 | * @generated |
| 3175 | */ | 3976 | */ |
| 3176 | EReference GLOBAL_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getGlobalRelationInterpretation_Symbol(); | 3977 | EClass CONJUNCTION = eINSTANCE.getConjunction(); |
| 3177 | 3978 | ||
| 3178 | /** | 3979 | /** |
| 3179 | * The meta object literal for the '<em><b>Source Multiplicity</b></em>' containment reference feature. | 3980 | * The meta object literal for the '<em><b>Children</b></em>' containment reference list feature. |
| 3180 | * <!-- begin-user-doc --> | 3981 | * <!-- begin-user-doc --> |
| 3181 | * <!-- end-user-doc --> | 3982 | * <!-- end-user-doc --> |
| 3182 | * @generated | 3983 | * @generated |
| 3183 | */ | 3984 | */ |
| 3184 | EReference GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_SourceMultiplicity(); | 3985 | EReference CONJUNCTION__CHILDREN = eINSTANCE.getConjunction_Children(); |
| 3185 | 3986 | ||
| 3186 | /** | 3987 | /** |
| 3187 | * The meta object literal for the '<em><b>Source</b></em>' containment reference feature. | 3988 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl <em>Comparison</em>}' class. |
| 3188 | * <!-- begin-user-doc --> | 3989 | * <!-- begin-user-doc --> |
| 3189 | * <!-- end-user-doc --> | 3990 | * <!-- end-user-doc --> |
| 3991 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl | ||
| 3992 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComparison() | ||
| 3190 | * @generated | 3993 | * @generated |
| 3191 | */ | 3994 | */ |
| 3192 | EReference GLOBAL_RELATION_INTERPRETATION__SOURCE = eINSTANCE.getGlobalRelationInterpretation_Source(); | 3995 | EClass COMPARISON = eINSTANCE.getComparison(); |
| 3193 | 3996 | ||
| 3194 | /** | 3997 | /** |
| 3195 | * The meta object literal for the '<em><b>Target Multiplicity</b></em>' containment reference feature. | 3998 | * The meta object literal for the '<em><b>Left</b></em>' containment reference feature. |
| 3196 | * <!-- begin-user-doc --> | 3999 | * <!-- begin-user-doc --> |
| 3197 | * <!-- end-user-doc --> | 4000 | * <!-- end-user-doc --> |
| 3198 | * @generated | 4001 | * @generated |
| 3199 | */ | 4002 | */ |
| 3200 | EReference GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_TargetMultiplicity(); | 4003 | EReference COMPARISON__LEFT = eINSTANCE.getComparison_Left(); |
| 3201 | 4004 | ||
| 3202 | /** | 4005 | /** |
| 3203 | * The meta object literal for the '<em><b>Target</b></em>' containment reference feature. | 4006 | * The meta object literal for the '<em><b>Op</b></em>' attribute feature. |
| 3204 | * <!-- begin-user-doc --> | 4007 | * <!-- begin-user-doc --> |
| 3205 | * <!-- end-user-doc --> | 4008 | * <!-- end-user-doc --> |
| 3206 | * @generated | 4009 | * @generated |
| 3207 | */ | 4010 | */ |
| 3208 | EReference GLOBAL_RELATION_INTERPRETATION__TARGET = eINSTANCE.getGlobalRelationInterpretation_Target(); | 4011 | EAttribute COMPARISON__OP = eINSTANCE.getComparison_Op(); |
| 3209 | 4012 | ||
| 3210 | /** | 4013 | /** |
| 3211 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl <em>Multiplicity Definition</em>}' class. | 4014 | * The meta object literal for the '<em><b>Right</b></em>' containment reference feature. |
| 3212 | * <!-- begin-user-doc --> | 4015 | * <!-- begin-user-doc --> |
| 3213 | * <!-- end-user-doc --> | 4016 | * <!-- end-user-doc --> |
| 3214 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl | ||
| 3215 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition() | ||
| 3216 | * @generated | 4017 | * @generated |
| 3217 | */ | 4018 | */ |
| 3218 | EClass MULTIPLICITY_DEFINITION = eINSTANCE.getMultiplicityDefinition(); | 4019 | EReference COMPARISON__RIGHT = eINSTANCE.getComparison_Right(); |
| 3219 | 4020 | ||
| 3220 | /** | 4021 | /** |
| 3221 | * The meta object literal for the '<em><b>Lower</b></em>' attribute feature. | 4022 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl <em>Binary Expression</em>}' class. |
| 3222 | * <!-- begin-user-doc --> | 4023 | * <!-- begin-user-doc --> |
| 3223 | * <!-- end-user-doc --> | 4024 | * <!-- end-user-doc --> |
| 4025 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl | ||
| 4026 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBinaryExpression() | ||
| 3224 | * @generated | 4027 | * @generated |
| 3225 | */ | 4028 | */ |
| 3226 | EAttribute MULTIPLICITY_DEFINITION__LOWER = eINSTANCE.getMultiplicityDefinition_Lower(); | 4029 | EClass BINARY_EXPRESSION = eINSTANCE.getBinaryExpression(); |
| 3227 | 4030 | ||
| 3228 | /** | 4031 | /** |
| 3229 | * The meta object literal for the '<em><b>Upper</b></em>' attribute feature. | 4032 | * The meta object literal for the '<em><b>Left</b></em>' containment reference feature. |
| 3230 | * <!-- begin-user-doc --> | 4033 | * <!-- begin-user-doc --> |
| 3231 | * <!-- end-user-doc --> | 4034 | * <!-- end-user-doc --> |
| 3232 | * @generated | 4035 | * @generated |
| 3233 | */ | 4036 | */ |
| 3234 | EAttribute MULTIPLICITY_DEFINITION__UPPER = eINSTANCE.getMultiplicityDefinition_Upper(); | 4037 | EReference BINARY_EXPRESSION__LEFT = eINSTANCE.getBinaryExpression_Left(); |
| 3235 | 4038 | ||
| 3236 | /** | 4039 | /** |
| 3237 | * The meta object literal for the '<em><b>Unlimited Upper</b></em>' attribute feature. | 4040 | * The meta object literal for the '<em><b>Op</b></em>' attribute feature. |
| 3238 | * <!-- begin-user-doc --> | 4041 | * <!-- begin-user-doc --> |
| 3239 | * <!-- end-user-doc --> | 4042 | * <!-- end-user-doc --> |
| 3240 | * @generated | 4043 | * @generated |
| 3241 | */ | 4044 | */ |
| 3242 | EAttribute MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = eINSTANCE.getMultiplicityDefinition_UnlimitedUpper(); | 4045 | EAttribute BINARY_EXPRESSION__OP = eINSTANCE.getBinaryExpression_Op(); |
| 3243 | 4046 | ||
| 3244 | /** | 4047 | /** |
| 3245 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl <em>Boolean True</em>}' class. | 4048 | * The meta object literal for the '<em><b>Right</b></em>' containment reference feature. |
| 3246 | * <!-- begin-user-doc --> | 4049 | * <!-- begin-user-doc --> |
| 3247 | * <!-- end-user-doc --> | 4050 | * <!-- end-user-doc --> |
| 3248 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl | ||
| 3249 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue() | ||
| 3250 | * @generated | 4051 | * @generated |
| 3251 | */ | 4052 | */ |
| 3252 | EClass BOOLEAN_TRUE = eINSTANCE.getBooleanTrue(); | 4053 | EReference BINARY_EXPRESSION__RIGHT = eINSTANCE.getBinaryExpression_Right(); |
| 3253 | 4054 | ||
| 3254 | /** | 4055 | /** |
| 3255 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl <em>Boolean False</em>}' class. | 4056 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl <em>Unary Expression</em>}' class. |
| 3256 | * <!-- begin-user-doc --> | 4057 | * <!-- begin-user-doc --> |
| 3257 | * <!-- end-user-doc --> | 4058 | * <!-- end-user-doc --> |
| 3258 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl | 4059 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl |
| 3259 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse() | 4060 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnaryExpression() |
| 3260 | * @generated | 4061 | * @generated |
| 3261 | */ | 4062 | */ |
| 3262 | EClass BOOLEAN_FALSE = eINSTANCE.getBooleanFalse(); | 4063 | EClass UNARY_EXPRESSION = eINSTANCE.getUnaryExpression(); |
| 3263 | 4064 | ||
| 3264 | /** | 4065 | /** |
| 3265 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl <em>True</em>}' class. | 4066 | * The meta object literal for the '<em><b>Op</b></em>' attribute feature. |
| 3266 | * <!-- begin-user-doc --> | 4067 | * <!-- begin-user-doc --> |
| 3267 | * <!-- end-user-doc --> | 4068 | * <!-- end-user-doc --> |
| 3268 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl | ||
| 3269 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue() | ||
| 3270 | * @generated | 4069 | * @generated |
| 3271 | */ | 4070 | */ |
| 3272 | EClass TRUE = eINSTANCE.getTrue(); | 4071 | EAttribute UNARY_EXPRESSION__OP = eINSTANCE.getUnaryExpression_Op(); |
| 3273 | 4072 | ||
| 3274 | /** | 4073 | /** |
| 3275 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl <em>False</em>}' class. | 4074 | * The meta object literal for the '<em><b>Body</b></em>' containment reference feature. |
| 3276 | * <!-- begin-user-doc --> | 4075 | * <!-- begin-user-doc --> |
| 3277 | * <!-- end-user-doc --> | 4076 | * <!-- end-user-doc --> |
| 3278 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl | ||
| 3279 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse() | ||
| 3280 | * @generated | 4077 | * @generated |
| 3281 | */ | 4078 | */ |
| 3282 | EClass FALSE = eINSTANCE.getFalse(); | 4079 | EReference UNARY_EXPRESSION__BODY = eINSTANCE.getUnaryExpression_Body(); |
| 3283 | 4080 | ||
| 3284 | /** | 4081 | /** |
| 3285 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl <em>Unknown</em>}' class. | 4082 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricType <em>Metric Type</em>}' enum. |
| 3286 | * <!-- begin-user-doc --> | 4083 | * <!-- begin-user-doc --> |
| 3287 | * <!-- end-user-doc --> | 4084 | * <!-- end-user-doc --> |
| 3288 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl | 4085 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricType |
| 3289 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown() | 4086 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMetricType() |
| 3290 | * @generated | 4087 | * @generated |
| 3291 | */ | 4088 | */ |
| 3292 | EClass UNKNOWN = eINSTANCE.getUnknown(); | 4089 | EEnum METRIC_TYPE = eINSTANCE.getMetricType(); |
| 3293 | 4090 | ||
| 3294 | /** | 4091 | /** |
| 3295 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl <em>Error</em>}' class. | 4092 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator <em>Binary Operator</em>}' enum. |
| 3296 | * <!-- begin-user-doc --> | 4093 | * <!-- begin-user-doc --> |
| 3297 | * <!-- end-user-doc --> | 4094 | * <!-- end-user-doc --> |
| 3298 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl | 4095 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator |
| 3299 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError() | 4096 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBinaryOperator() |
| 3300 | * @generated | 4097 | * @generated |
| 3301 | */ | 4098 | */ |
| 3302 | EClass ERROR = eINSTANCE.getError(); | 4099 | EEnum BINARY_OPERATOR = eINSTANCE.getBinaryOperator(); |
| 3303 | 4100 | ||
| 3304 | /** | 4101 | /** |
| 3305 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl <em>Positive</em>}' class. | 4102 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryOp <em>Unary Op</em>}' enum. |
| 3306 | * <!-- begin-user-doc --> | 4103 | * <!-- begin-user-doc --> |
| 3307 | * <!-- end-user-doc --> | 4104 | * <!-- end-user-doc --> |
| 3308 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl | 4105 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryOp |
| 3309 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive() | 4106 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnaryOp() |
| 3310 | * @generated | 4107 | * @generated |
| 3311 | */ | 4108 | */ |
| 3312 | EClass POSITIVE = eINSTANCE.getPositive(); | 4109 | EEnum UNARY_OP = eINSTANCE.getUnaryOp(); |
| 3313 | 4110 | ||
| 3314 | /** | 4111 | /** |
| 3315 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl <em>Negative</em>}' class. | 4112 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.AggregationOp <em>Aggregation Op</em>}' enum. |
| 3316 | * <!-- begin-user-doc --> | 4113 | * <!-- begin-user-doc --> |
| 3317 | * <!-- end-user-doc --> | 4114 | * <!-- end-user-doc --> |
| 3318 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl | 4115 | * @see org.eclipse.viatra.solver.language.solverLanguage.AggregationOp |
| 3319 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative() | 4116 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAggregationOp() |
| 3320 | * @generated | 4117 | * @generated |
| 3321 | */ | 4118 | */ |
| 3322 | EClass NEGATIVE = eINSTANCE.getNegative(); | 4119 | EEnum AGGREGATION_OP = eINSTANCE.getAggregationOp(); |
| 3323 | 4120 | ||
| 3324 | /** | 4121 | /** |
| 3325 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl <em>Reflexive Closure</em>}' class. | 4122 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicValue <em>Logic Value</em>}' enum. |
| 3326 | * <!-- begin-user-doc --> | 4123 | * <!-- begin-user-doc --> |
| 3327 | * <!-- end-user-doc --> | 4124 | * <!-- end-user-doc --> |
| 3328 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl | 4125 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicValue |
| 3329 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure() | 4126 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLogicValue() |
| 3330 | * @generated | 4127 | * @generated |
| 3331 | */ | 4128 | */ |
| 3332 | EClass REFLEXIVE_CLOSURE = eINSTANCE.getReflexiveClosure(); | 4129 | EEnum LOGIC_VALUE = eINSTANCE.getLogicValue(); |
| 3333 | 4130 | ||
| 3334 | /** | 4131 | /** |
| 3335 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl <em>Irreflexive Closure</em>}' class. | 4132 | * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind <em>Objective Kind</em>}' enum. |
| 3336 | * <!-- begin-user-doc --> | 4133 | * <!-- begin-user-doc --> |
| 3337 | * <!-- end-user-doc --> | 4134 | * <!-- end-user-doc --> |
| 3338 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl | 4135 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind |
| 3339 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure() | 4136 | * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObjectiveKind() |
| 3340 | * @generated | 4137 | * @generated |
| 3341 | */ | 4138 | */ |
| 3342 | EClass IRREFLEXIVE_CLOSURE = eINSTANCE.getIrreflexiveClosure(); | 4139 | EEnum OBJECTIVE_KIND = eINSTANCE.getObjectiveKind(); |
| 3343 | 4140 | ||
| 3344 | } | 4141 | } |
| 3345 | 4142 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StarArgument.java index f3d6d8ee..4e4bed1b 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StarArgument.java | |||
| @@ -1,19 +1,19 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | 6 | ||
| 7 | /** | 7 | /** |
| 8 | * <!-- begin-user-doc --> | 8 | * <!-- begin-user-doc --> |
| 9 | * A representation of the model object '<em><b>String Symbol</b></em>'. | 9 | * A representation of the model object '<em><b>Star Argument</b></em>'. |
| 10 | * <!-- end-user-doc --> | 10 | * <!-- end-user-doc --> |
| 11 | * | 11 | * |
| 12 | * | 12 | * |
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringSymbol() | 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStarArgument() |
| 14 | * @model | 14 | * @model |
| 15 | * @generated | 15 | * @generated |
| 16 | */ | 16 | */ |
| 17 | public interface StringSymbol extends DataSymbol | 17 | public interface StarArgument extends Argument |
| 18 | { | 18 | { |
| 19 | } // StringSymbol | 19 | } // StarArgument |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java index f3da8f9c..7c8d208f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringLiteral.java index d1d3ee6d..dc4d6487 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringLiteral.java | |||
| @@ -1,26 +1,26 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | 4 | package org.eclipse.viatra.solver.language.solverLanguage; |
| 5 | 5 | ||
| 6 | 6 | ||
| 7 | /** | 7 | /** |
| 8 | * <!-- begin-user-doc --> | 8 | * <!-- begin-user-doc --> |
| 9 | * A representation of the model object '<em><b>String Object</b></em>'. | 9 | * A representation of the model object '<em><b>String Literal</b></em>'. |
| 10 | * <!-- end-user-doc --> | 10 | * <!-- end-user-doc --> |
| 11 | * | 11 | * |
| 12 | * <p> | 12 | * <p> |
| 13 | * The following features are supported: | 13 | * The following features are supported: |
| 14 | * </p> | 14 | * </p> |
| 15 | * <ul> | 15 | * <ul> |
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}</li> | 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral#getValue <em>Value</em>}</li> |
| 17 | * </ul> | 17 | * </ul> |
| 18 | * | 18 | * |
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject() | 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringLiteral() |
| 20 | * @model | 20 | * @model |
| 21 | * @generated | 21 | * @generated |
| 22 | */ | 22 | */ |
| 23 | public interface StringObject extends DataObject | 23 | public interface StringLiteral extends Literal |
| 24 | { | 24 | { |
| 25 | /** | 25 | /** |
| 26 | * Returns the value of the '<em><b>Value</b></em>' attribute. | 26 | * Returns the value of the '<em><b>Value</b></em>' attribute. |
| @@ -28,14 +28,14 @@ public interface StringObject extends DataObject | |||
| 28 | * <!-- end-user-doc --> | 28 | * <!-- end-user-doc --> |
| 29 | * @return the value of the '<em>Value</em>' attribute. | 29 | * @return the value of the '<em>Value</em>' attribute. |
| 30 | * @see #setValue(String) | 30 | * @see #setValue(String) |
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject_Value() | 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringLiteral_Value() |
| 32 | * @model | 32 | * @model |
| 33 | * @generated | 33 | * @generated |
| 34 | */ | 34 | */ |
| 35 | String getValue(); | 35 | String getValue(); |
| 36 | 36 | ||
| 37 | /** | 37 | /** |
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}' attribute. | 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral#getValue <em>Value</em>}' attribute. |
| 39 | * <!-- begin-user-doc --> | 39 | * <!-- begin-user-doc --> |
| 40 | * <!-- end-user-doc --> | 40 | * <!-- end-user-doc --> |
| 41 | * @param value the new value of the '<em>Value</em>' attribute. | 41 | * @param value the new value of the '<em>Value</em>' attribute. |
| @@ -44,4 +44,4 @@ public interface StringObject extends DataObject | |||
| 44 | */ | 44 | */ |
| 45 | void setValue(String value); | 45 | void setValue(String value); |
| 46 | 46 | ||
| 47 | } // StringObject | 47 | } // StringLiteral |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Switch.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Switch.java new file mode 100644 index 00000000..92504b5d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Switch.java | |||
| @@ -0,0 +1,38 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.util.EList; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Switch</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * <p> | ||
| 14 | * The following features are supported: | ||
| 15 | * </p> | ||
| 16 | * <ul> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Switch#getCases <em>Cases</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getSwitch() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface Switch extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Cases</b></em>' containment reference list. | ||
| 28 | * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Case}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Cases</em>' containment reference list. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getSwitch_Cases() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | EList<Case> getCases(); | ||
| 37 | |||
| 38 | } // Switch | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java deleted file mode 100644 index dcf2a01a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Symbol</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * | ||
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getSymbol() | ||
| 15 | * @model | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public interface Symbol extends EObject | ||
| 19 | { | ||
| 20 | } // Symbol | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java deleted file mode 100644 index d125d86a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>True</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTrue() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface True extends TruthValue | ||
| 18 | { | ||
| 19 | } // True | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java deleted file mode 100644 index 48e2b8e8..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EObject; | ||
| 7 | |||
| 8 | /** | ||
| 9 | * <!-- begin-user-doc --> | ||
| 10 | * A representation of the model object '<em><b>Truth Value</b></em>'. | ||
| 11 | * <!-- end-user-doc --> | ||
| 12 | * | ||
| 13 | * | ||
| 14 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTruthValue() | ||
| 15 | * @model | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public interface TruthValue extends EObject | ||
| 19 | { | ||
| 20 | } // TruthValue | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedArgument.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedArgument.java new file mode 100644 index 00000000..f903338a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedArgument.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Typed Argument</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getType <em>Type</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getVariable <em>Variable</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTypedArgument() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface TypedArgument extends Argument | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Type</b></em>' reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Type</em>' reference. | ||
| 31 | * @see #setType(NamedElement) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTypedArgument_Type() | ||
| 33 | * @model | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | NamedElement getType(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getType <em>Type</em>}' reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Type</em>' reference. | ||
| 43 | * @see #getType() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setType(NamedElement value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Variable</b></em>' reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Variable</em>' reference. | ||
| 53 | * @see #setVariable(NamedElement) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTypedArgument_Variable() | ||
| 55 | * @model | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | NamedElement getVariable(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument#getVariable <em>Variable</em>}' reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Variable</em>' reference. | ||
| 65 | * @see #getVariable() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setVariable(NamedElement value); | ||
| 69 | |||
| 70 | } // TypedArgument | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedStarArgument.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedStarArgument.java new file mode 100644 index 00000000..2b8bc002 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TypedStarArgument.java | |||
| @@ -0,0 +1,47 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Typed Star Argument</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument#getType <em>Type</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTypedStarArgument() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface TypedStarArgument extends Argument | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Type</b></em>' reference. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Type</em>' reference. | ||
| 30 | * @see #setType(NamedElement) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTypedStarArgument_Type() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | NamedElement getType(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument#getType <em>Type</em>}' reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Type</em>' reference. | ||
| 42 | * @see #getType() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setType(NamedElement value); | ||
| 46 | |||
| 47 | } // TypedStarArgument | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryExpression.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryExpression.java new file mode 100644 index 00000000..5c2356cd --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryExpression.java | |||
| @@ -0,0 +1,73 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Unary Expression</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getOp <em>Op</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getBody <em>Body</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnaryExpression() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface UnaryExpression extends Expression | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Op</b></em>' attribute. | ||
| 28 | * The literals are from the enumeration {@link org.eclipse.viatra.solver.language.solverLanguage.UnaryOp}. | ||
| 29 | * <!-- begin-user-doc --> | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * @return the value of the '<em>Op</em>' attribute. | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryOp | ||
| 33 | * @see #setOp(UnaryOp) | ||
| 34 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnaryExpression_Op() | ||
| 35 | * @model | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | UnaryOp getOp(); | ||
| 39 | |||
| 40 | /** | ||
| 41 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getOp <em>Op</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @param value the new value of the '<em>Op</em>' attribute. | ||
| 45 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryOp | ||
| 46 | * @see #getOp() | ||
| 47 | * @generated | ||
| 48 | */ | ||
| 49 | void setOp(UnaryOp value); | ||
| 50 | |||
| 51 | /** | ||
| 52 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 56 | * @see #setBody(Expression) | ||
| 57 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnaryExpression_Body() | ||
| 58 | * @model containment="true" | ||
| 59 | * @generated | ||
| 60 | */ | ||
| 61 | Expression getBody(); | ||
| 62 | |||
| 63 | /** | ||
| 64 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression#getBody <em>Body</em>}' containment reference. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 68 | * @see #getBody() | ||
| 69 | * @generated | ||
| 70 | */ | ||
| 71 | void setBody(Expression value); | ||
| 72 | |||
| 73 | } // UnaryExpression | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryOp.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryOp.java new file mode 100644 index 00000000..e426f4f1 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnaryOp.java | |||
| @@ -0,0 +1,317 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | import java.util.Arrays; | ||
| 7 | import java.util.Collections; | ||
| 8 | import java.util.List; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.Enumerator; | ||
| 11 | |||
| 12 | /** | ||
| 13 | * <!-- begin-user-doc --> | ||
| 14 | * A representation of the literals of the enumeration '<em><b>Unary Op</b></em>', | ||
| 15 | * and utility methods for working with them. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnaryOp() | ||
| 18 | * @model | ||
| 19 | * @generated | ||
| 20 | */ | ||
| 21 | public enum UnaryOp implements Enumerator | ||
| 22 | { | ||
| 23 | /** | ||
| 24 | * The '<em><b>NEG</b></em>' literal object. | ||
| 25 | * <!-- begin-user-doc --> | ||
| 26 | * <!-- end-user-doc --> | ||
| 27 | * @see #NEG_VALUE | ||
| 28 | * @generated | ||
| 29 | * @ordered | ||
| 30 | */ | ||
| 31 | NEG(0, "NEG", "!"), | ||
| 32 | |||
| 33 | /** | ||
| 34 | * The '<em><b>PLUS</b></em>' literal object. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #PLUS_VALUE | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | PLUS(1, "PLUS", "+"), | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The '<em><b>MINUS</b></em>' literal object. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #MINUS_VALUE | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | MINUS(2, "MINUS", "-"), | ||
| 52 | |||
| 53 | /** | ||
| 54 | * The '<em><b>MAY</b></em>' literal object. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @see #MAY_VALUE | ||
| 58 | * @generated | ||
| 59 | * @ordered | ||
| 60 | */ | ||
| 61 | MAY(3, "MAY", "may"), | ||
| 62 | |||
| 63 | /** | ||
| 64 | * The '<em><b>MUST</b></em>' literal object. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @see #MUST_VALUE | ||
| 68 | * @generated | ||
| 69 | * @ordered | ||
| 70 | */ | ||
| 71 | MUST(4, "MUST", "must"), | ||
| 72 | |||
| 73 | /** | ||
| 74 | * The '<em><b>CURRENT</b></em>' literal object. | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @see #CURRENT_VALUE | ||
| 78 | * @generated | ||
| 79 | * @ordered | ||
| 80 | */ | ||
| 81 | CURRENT(5, "CURRENT", "current"); | ||
| 82 | |||
| 83 | /** | ||
| 84 | * The '<em><b>NEG</b></em>' literal value. | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @see #NEG | ||
| 88 | * @model literal="!" | ||
| 89 | * @generated | ||
| 90 | * @ordered | ||
| 91 | */ | ||
| 92 | public static final int NEG_VALUE = 0; | ||
| 93 | |||
| 94 | /** | ||
| 95 | * The '<em><b>PLUS</b></em>' literal value. | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @see #PLUS | ||
| 99 | * @model literal="+" | ||
| 100 | * @generated | ||
| 101 | * @ordered | ||
| 102 | */ | ||
| 103 | public static final int PLUS_VALUE = 1; | ||
| 104 | |||
| 105 | /** | ||
| 106 | * The '<em><b>MINUS</b></em>' literal value. | ||
| 107 | * <!-- begin-user-doc --> | ||
| 108 | * <!-- end-user-doc --> | ||
| 109 | * @see #MINUS | ||
| 110 | * @model literal="-" | ||
| 111 | * @generated | ||
| 112 | * @ordered | ||
| 113 | */ | ||
| 114 | public static final int MINUS_VALUE = 2; | ||
| 115 | |||
| 116 | /** | ||
| 117 | * The '<em><b>MAY</b></em>' literal value. | ||
| 118 | * <!-- begin-user-doc --> | ||
| 119 | * <!-- end-user-doc --> | ||
| 120 | * @see #MAY | ||
| 121 | * @model literal="may" | ||
| 122 | * @generated | ||
| 123 | * @ordered | ||
| 124 | */ | ||
| 125 | public static final int MAY_VALUE = 3; | ||
| 126 | |||
| 127 | /** | ||
| 128 | * The '<em><b>MUST</b></em>' literal value. | ||
| 129 | * <!-- begin-user-doc --> | ||
| 130 | * <!-- end-user-doc --> | ||
| 131 | * @see #MUST | ||
| 132 | * @model literal="must" | ||
| 133 | * @generated | ||
| 134 | * @ordered | ||
| 135 | */ | ||
| 136 | public static final int MUST_VALUE = 4; | ||
| 137 | |||
| 138 | /** | ||
| 139 | * The '<em><b>CURRENT</b></em>' literal value. | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @see #CURRENT | ||
| 143 | * @model literal="current" | ||
| 144 | * @generated | ||
| 145 | * @ordered | ||
| 146 | */ | ||
| 147 | public static final int CURRENT_VALUE = 5; | ||
| 148 | |||
| 149 | /** | ||
| 150 | * An array of all the '<em><b>Unary Op</b></em>' enumerators. | ||
| 151 | * <!-- begin-user-doc --> | ||
| 152 | * <!-- end-user-doc --> | ||
| 153 | * @generated | ||
| 154 | */ | ||
| 155 | private static final UnaryOp[] VALUES_ARRAY = | ||
| 156 | new UnaryOp[] | ||
| 157 | { | ||
| 158 | NEG, | ||
| 159 | PLUS, | ||
| 160 | MINUS, | ||
| 161 | MAY, | ||
| 162 | MUST, | ||
| 163 | CURRENT, | ||
| 164 | }; | ||
| 165 | |||
| 166 | /** | ||
| 167 | * A public read-only list of all the '<em><b>Unary Op</b></em>' enumerators. | ||
| 168 | * <!-- begin-user-doc --> | ||
| 169 | * <!-- end-user-doc --> | ||
| 170 | * @generated | ||
| 171 | */ | ||
| 172 | public static final List<UnaryOp> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY)); | ||
| 173 | |||
| 174 | /** | ||
| 175 | * Returns the '<em><b>Unary Op</b></em>' literal with the specified literal value. | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @param literal the literal. | ||
| 179 | * @return the matching enumerator or <code>null</code>. | ||
| 180 | * @generated | ||
| 181 | */ | ||
| 182 | public static UnaryOp get(String literal) | ||
| 183 | { | ||
| 184 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 185 | { | ||
| 186 | UnaryOp result = VALUES_ARRAY[i]; | ||
| 187 | if (result.toString().equals(literal)) | ||
| 188 | { | ||
| 189 | return result; | ||
| 190 | } | ||
| 191 | } | ||
| 192 | return null; | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * Returns the '<em><b>Unary Op</b></em>' literal with the specified name. | ||
| 197 | * <!-- begin-user-doc --> | ||
| 198 | * <!-- end-user-doc --> | ||
| 199 | * @param name the name. | ||
| 200 | * @return the matching enumerator or <code>null</code>. | ||
| 201 | * @generated | ||
| 202 | */ | ||
| 203 | public static UnaryOp getByName(String name) | ||
| 204 | { | ||
| 205 | for (int i = 0; i < VALUES_ARRAY.length; ++i) | ||
| 206 | { | ||
| 207 | UnaryOp result = VALUES_ARRAY[i]; | ||
| 208 | if (result.getName().equals(name)) | ||
| 209 | { | ||
| 210 | return result; | ||
| 211 | } | ||
| 212 | } | ||
| 213 | return null; | ||
| 214 | } | ||
| 215 | |||
| 216 | /** | ||
| 217 | * Returns the '<em><b>Unary Op</b></em>' literal with the specified integer value. | ||
| 218 | * <!-- begin-user-doc --> | ||
| 219 | * <!-- end-user-doc --> | ||
| 220 | * @param value the integer value. | ||
| 221 | * @return the matching enumerator or <code>null</code>. | ||
| 222 | * @generated | ||
| 223 | */ | ||
| 224 | public static UnaryOp get(int value) | ||
| 225 | { | ||
| 226 | switch (value) | ||
| 227 | { | ||
| 228 | case NEG_VALUE: return NEG; | ||
| 229 | case PLUS_VALUE: return PLUS; | ||
| 230 | case MINUS_VALUE: return MINUS; | ||
| 231 | case MAY_VALUE: return MAY; | ||
| 232 | case MUST_VALUE: return MUST; | ||
| 233 | case CURRENT_VALUE: return CURRENT; | ||
| 234 | } | ||
| 235 | return null; | ||
| 236 | } | ||
| 237 | |||
| 238 | /** | ||
| 239 | * <!-- begin-user-doc --> | ||
| 240 | * <!-- end-user-doc --> | ||
| 241 | * @generated | ||
| 242 | */ | ||
| 243 | private final int value; | ||
| 244 | |||
| 245 | /** | ||
| 246 | * <!-- begin-user-doc --> | ||
| 247 | * <!-- end-user-doc --> | ||
| 248 | * @generated | ||
| 249 | */ | ||
| 250 | private final String name; | ||
| 251 | |||
| 252 | /** | ||
| 253 | * <!-- begin-user-doc --> | ||
| 254 | * <!-- end-user-doc --> | ||
| 255 | * @generated | ||
| 256 | */ | ||
| 257 | private final String literal; | ||
| 258 | |||
| 259 | /** | ||
| 260 | * Only this class can construct instances. | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | private UnaryOp(int value, String name, String literal) | ||
| 266 | { | ||
| 267 | this.value = value; | ||
| 268 | this.name = name; | ||
| 269 | this.literal = literal; | ||
| 270 | } | ||
| 271 | |||
| 272 | /** | ||
| 273 | * <!-- begin-user-doc --> | ||
| 274 | * <!-- end-user-doc --> | ||
| 275 | * @generated | ||
| 276 | */ | ||
| 277 | @Override | ||
| 278 | public int getValue() | ||
| 279 | { | ||
| 280 | return value; | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public String getName() | ||
| 290 | { | ||
| 291 | return name; | ||
| 292 | } | ||
| 293 | |||
| 294 | /** | ||
| 295 | * <!-- begin-user-doc --> | ||
| 296 | * <!-- end-user-doc --> | ||
| 297 | * @generated | ||
| 298 | */ | ||
| 299 | @Override | ||
| 300 | public String getLiteral() | ||
| 301 | { | ||
| 302 | return literal; | ||
| 303 | } | ||
| 304 | |||
| 305 | /** | ||
| 306 | * Returns the literal value of the enumerator, which is its string representation. | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public String toString() | ||
| 313 | { | ||
| 314 | return literal; | ||
| 315 | } | ||
| 316 | |||
| 317 | } //UnaryOp | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java deleted file mode 100644 index 496f433a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Unknown</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * | ||
| 13 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnknown() | ||
| 14 | * @model | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public interface Unknown extends TruthValue | ||
| 18 | { | ||
| 19 | } // Unknown | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedErrorPrediateDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedErrorPrediateDefinition.java new file mode 100644 index 00000000..54621550 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedErrorPrediateDefinition.java | |||
| @@ -0,0 +1,70 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Unnamed Error Prediate Definition</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getArgumentList <em>Argument List</em>}</li> | ||
| 17 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getBody <em>Body</em>}</li> | ||
| 18 | * </ul> | ||
| 19 | * | ||
| 20 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedErrorPrediateDefinition() | ||
| 21 | * @model | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | public interface UnnamedErrorPrediateDefinition extends Statement | ||
| 25 | { | ||
| 26 | /** | ||
| 27 | * Returns the value of the '<em><b>Argument List</b></em>' containment reference. | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * @return the value of the '<em>Argument List</em>' containment reference. | ||
| 31 | * @see #setArgumentList(ArgumentList) | ||
| 32 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedErrorPrediateDefinition_ArgumentList() | ||
| 33 | * @model containment="true" | ||
| 34 | * @generated | ||
| 35 | */ | ||
| 36 | ArgumentList getArgumentList(); | ||
| 37 | |||
| 38 | /** | ||
| 39 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getArgumentList <em>Argument List</em>}' containment reference. | ||
| 40 | * <!-- begin-user-doc --> | ||
| 41 | * <!-- end-user-doc --> | ||
| 42 | * @param value the new value of the '<em>Argument List</em>' containment reference. | ||
| 43 | * @see #getArgumentList() | ||
| 44 | * @generated | ||
| 45 | */ | ||
| 46 | void setArgumentList(ArgumentList value); | ||
| 47 | |||
| 48 | /** | ||
| 49 | * Returns the value of the '<em><b>Body</b></em>' containment reference. | ||
| 50 | * <!-- begin-user-doc --> | ||
| 51 | * <!-- end-user-doc --> | ||
| 52 | * @return the value of the '<em>Body</em>' containment reference. | ||
| 53 | * @see #setBody(Expression) | ||
| 54 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedErrorPrediateDefinition_Body() | ||
| 55 | * @model containment="true" | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | Expression getBody(); | ||
| 59 | |||
| 60 | /** | ||
| 61 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition#getBody <em>Body</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @param value the new value of the '<em>Body</em>' containment reference. | ||
| 65 | * @see #getBody() | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | void setBody(Expression value); | ||
| 69 | |||
| 70 | } // UnnamedErrorPrediateDefinition | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java deleted file mode 100644 index 152ee782..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Unnamed Object</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface UnnamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Name</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Name</em>' attribute. | ||
| 30 | * @see #setName(String) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject_Name() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | String getName(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Name</em>' attribute. | ||
| 42 | * @see #getName() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setName(String value); | ||
| 46 | |||
| 47 | } // UnnamedObject | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java deleted file mode 100644 index 2f915fa7..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage; | ||
| 5 | |||
| 6 | |||
| 7 | /** | ||
| 8 | * <!-- begin-user-doc --> | ||
| 9 | * A representation of the model object '<em><b>Variable</b></em>'. | ||
| 10 | * <!-- end-user-doc --> | ||
| 11 | * | ||
| 12 | * <p> | ||
| 13 | * The following features are supported: | ||
| 14 | * </p> | ||
| 15 | * <ul> | ||
| 16 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}</li> | ||
| 17 | * </ul> | ||
| 18 | * | ||
| 19 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable() | ||
| 20 | * @model | ||
| 21 | * @generated | ||
| 22 | */ | ||
| 23 | public interface Variable extends Literal | ||
| 24 | { | ||
| 25 | /** | ||
| 26 | * Returns the value of the '<em><b>Name</b></em>' attribute. | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * <!-- end-user-doc --> | ||
| 29 | * @return the value of the '<em>Name</em>' attribute. | ||
| 30 | * @see #setName(String) | ||
| 31 | * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable_Name() | ||
| 32 | * @model | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | String getName(); | ||
| 36 | |||
| 37 | /** | ||
| 38 | * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}' attribute. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @param value the new value of the '<em>Name</em>' attribute. | ||
| 42 | * @see #getName() | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | void setName(String value); | ||
| 46 | |||
| 47 | } // Variable | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AggregationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AggregationImpl.java new file mode 100644 index 00000000..542f3c40 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AggregationImpl.java | |||
| @@ -0,0 +1,343 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.AggregationOp; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Aggregation</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl#getOp <em>Op</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl#getBody <em>Body</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AggregationImpl#getCondition <em>Condition</em>}</li> | ||
| 30 | * </ul> | ||
| 31 | * | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | public class AggregationImpl extends ExpressionImpl implements Aggregation | ||
| 35 | { | ||
| 36 | /** | ||
| 37 | * The default value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 38 | * <!-- begin-user-doc --> | ||
| 39 | * <!-- end-user-doc --> | ||
| 40 | * @see #getOp() | ||
| 41 | * @generated | ||
| 42 | * @ordered | ||
| 43 | */ | ||
| 44 | protected static final AggregationOp OP_EDEFAULT = AggregationOp.ONLY; | ||
| 45 | |||
| 46 | /** | ||
| 47 | * The cached value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @see #getOp() | ||
| 51 | * @generated | ||
| 52 | * @ordered | ||
| 53 | */ | ||
| 54 | protected AggregationOp op = OP_EDEFAULT; | ||
| 55 | |||
| 56 | /** | ||
| 57 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @see #getBody() | ||
| 61 | * @generated | ||
| 62 | * @ordered | ||
| 63 | */ | ||
| 64 | protected Expression body; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * The cached value of the '{@link #getCondition() <em>Condition</em>}' containment reference. | ||
| 68 | * <!-- begin-user-doc --> | ||
| 69 | * <!-- end-user-doc --> | ||
| 70 | * @see #getCondition() | ||
| 71 | * @generated | ||
| 72 | * @ordered | ||
| 73 | */ | ||
| 74 | protected Expression condition; | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | protected AggregationImpl() | ||
| 82 | { | ||
| 83 | super(); | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | protected EClass eStaticClass() | ||
| 93 | { | ||
| 94 | return SolverLanguagePackage.Literals.AGGREGATION; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public AggregationOp getOp() | ||
| 104 | { | ||
| 105 | return op; | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | @Override | ||
| 114 | public void setOp(AggregationOp newOp) | ||
| 115 | { | ||
| 116 | AggregationOp oldOp = op; | ||
| 117 | op = newOp == null ? OP_EDEFAULT : newOp; | ||
| 118 | if (eNotificationRequired()) | ||
| 119 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.AGGREGATION__OP, oldOp, op)); | ||
| 120 | } | ||
| 121 | |||
| 122 | /** | ||
| 123 | * <!-- begin-user-doc --> | ||
| 124 | * <!-- end-user-doc --> | ||
| 125 | * @generated | ||
| 126 | */ | ||
| 127 | @Override | ||
| 128 | public Expression getBody() | ||
| 129 | { | ||
| 130 | return body; | ||
| 131 | } | ||
| 132 | |||
| 133 | /** | ||
| 134 | * <!-- begin-user-doc --> | ||
| 135 | * <!-- end-user-doc --> | ||
| 136 | * @generated | ||
| 137 | */ | ||
| 138 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 139 | { | ||
| 140 | Expression oldBody = body; | ||
| 141 | body = newBody; | ||
| 142 | if (eNotificationRequired()) | ||
| 143 | { | ||
| 144 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.AGGREGATION__BODY, oldBody, newBody); | ||
| 145 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 146 | } | ||
| 147 | return msgs; | ||
| 148 | } | ||
| 149 | |||
| 150 | /** | ||
| 151 | * <!-- begin-user-doc --> | ||
| 152 | * <!-- end-user-doc --> | ||
| 153 | * @generated | ||
| 154 | */ | ||
| 155 | @Override | ||
| 156 | public void setBody(Expression newBody) | ||
| 157 | { | ||
| 158 | if (newBody != body) | ||
| 159 | { | ||
| 160 | NotificationChain msgs = null; | ||
| 161 | if (body != null) | ||
| 162 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.AGGREGATION__BODY, null, msgs); | ||
| 163 | if (newBody != null) | ||
| 164 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.AGGREGATION__BODY, null, msgs); | ||
| 165 | msgs = basicSetBody(newBody, msgs); | ||
| 166 | if (msgs != null) msgs.dispatch(); | ||
| 167 | } | ||
| 168 | else if (eNotificationRequired()) | ||
| 169 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.AGGREGATION__BODY, newBody, newBody)); | ||
| 170 | } | ||
| 171 | |||
| 172 | /** | ||
| 173 | * <!-- begin-user-doc --> | ||
| 174 | * <!-- end-user-doc --> | ||
| 175 | * @generated | ||
| 176 | */ | ||
| 177 | @Override | ||
| 178 | public Expression getCondition() | ||
| 179 | { | ||
| 180 | return condition; | ||
| 181 | } | ||
| 182 | |||
| 183 | /** | ||
| 184 | * <!-- begin-user-doc --> | ||
| 185 | * <!-- end-user-doc --> | ||
| 186 | * @generated | ||
| 187 | */ | ||
| 188 | public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs) | ||
| 189 | { | ||
| 190 | Expression oldCondition = condition; | ||
| 191 | condition = newCondition; | ||
| 192 | if (eNotificationRequired()) | ||
| 193 | { | ||
| 194 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.AGGREGATION__CONDITION, oldCondition, newCondition); | ||
| 195 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 196 | } | ||
| 197 | return msgs; | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public void setCondition(Expression newCondition) | ||
| 207 | { | ||
| 208 | if (newCondition != condition) | ||
| 209 | { | ||
| 210 | NotificationChain msgs = null; | ||
| 211 | if (condition != null) | ||
| 212 | msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.AGGREGATION__CONDITION, null, msgs); | ||
| 213 | if (newCondition != null) | ||
| 214 | msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.AGGREGATION__CONDITION, null, msgs); | ||
| 215 | msgs = basicSetCondition(newCondition, msgs); | ||
| 216 | if (msgs != null) msgs.dispatch(); | ||
| 217 | } | ||
| 218 | else if (eNotificationRequired()) | ||
| 219 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.AGGREGATION__CONDITION, newCondition, newCondition)); | ||
| 220 | } | ||
| 221 | |||
| 222 | /** | ||
| 223 | * <!-- begin-user-doc --> | ||
| 224 | * <!-- end-user-doc --> | ||
| 225 | * @generated | ||
| 226 | */ | ||
| 227 | @Override | ||
| 228 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 229 | { | ||
| 230 | switch (featureID) | ||
| 231 | { | ||
| 232 | case SolverLanguagePackage.AGGREGATION__BODY: | ||
| 233 | return basicSetBody(null, msgs); | ||
| 234 | case SolverLanguagePackage.AGGREGATION__CONDITION: | ||
| 235 | return basicSetCondition(null, msgs); | ||
| 236 | } | ||
| 237 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 238 | } | ||
| 239 | |||
| 240 | /** | ||
| 241 | * <!-- begin-user-doc --> | ||
| 242 | * <!-- end-user-doc --> | ||
| 243 | * @generated | ||
| 244 | */ | ||
| 245 | @Override | ||
| 246 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 247 | { | ||
| 248 | switch (featureID) | ||
| 249 | { | ||
| 250 | case SolverLanguagePackage.AGGREGATION__OP: | ||
| 251 | return getOp(); | ||
| 252 | case SolverLanguagePackage.AGGREGATION__BODY: | ||
| 253 | return getBody(); | ||
| 254 | case SolverLanguagePackage.AGGREGATION__CONDITION: | ||
| 255 | return getCondition(); | ||
| 256 | } | ||
| 257 | return super.eGet(featureID, resolve, coreType); | ||
| 258 | } | ||
| 259 | |||
| 260 | /** | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | @Override | ||
| 266 | public void eSet(int featureID, Object newValue) | ||
| 267 | { | ||
| 268 | switch (featureID) | ||
| 269 | { | ||
| 270 | case SolverLanguagePackage.AGGREGATION__OP: | ||
| 271 | setOp((AggregationOp)newValue); | ||
| 272 | return; | ||
| 273 | case SolverLanguagePackage.AGGREGATION__BODY: | ||
| 274 | setBody((Expression)newValue); | ||
| 275 | return; | ||
| 276 | case SolverLanguagePackage.AGGREGATION__CONDITION: | ||
| 277 | setCondition((Expression)newValue); | ||
| 278 | return; | ||
| 279 | } | ||
| 280 | super.eSet(featureID, newValue); | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public void eUnset(int featureID) | ||
| 290 | { | ||
| 291 | switch (featureID) | ||
| 292 | { | ||
| 293 | case SolverLanguagePackage.AGGREGATION__OP: | ||
| 294 | setOp(OP_EDEFAULT); | ||
| 295 | return; | ||
| 296 | case SolverLanguagePackage.AGGREGATION__BODY: | ||
| 297 | setBody((Expression)null); | ||
| 298 | return; | ||
| 299 | case SolverLanguagePackage.AGGREGATION__CONDITION: | ||
| 300 | setCondition((Expression)null); | ||
| 301 | return; | ||
| 302 | } | ||
| 303 | super.eUnset(featureID); | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public boolean eIsSet(int featureID) | ||
| 313 | { | ||
| 314 | switch (featureID) | ||
| 315 | { | ||
| 316 | case SolverLanguagePackage.AGGREGATION__OP: | ||
| 317 | return op != OP_EDEFAULT; | ||
| 318 | case SolverLanguagePackage.AGGREGATION__BODY: | ||
| 319 | return body != null; | ||
| 320 | case SolverLanguagePackage.AGGREGATION__CONDITION: | ||
| 321 | return condition != null; | ||
| 322 | } | ||
| 323 | return super.eIsSet(featureID); | ||
| 324 | } | ||
| 325 | |||
| 326 | /** | ||
| 327 | * <!-- begin-user-doc --> | ||
| 328 | * <!-- end-user-doc --> | ||
| 329 | * @generated | ||
| 330 | */ | ||
| 331 | @Override | ||
| 332 | public String toString() | ||
| 333 | { | ||
| 334 | if (eIsProxy()) return super.toString(); | ||
| 335 | |||
| 336 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 337 | result.append(" (op: "); | ||
| 338 | result.append(op); | ||
| 339 | result.append(')'); | ||
| 340 | return result.toString(); | ||
| 341 | } | ||
| 342 | |||
| 343 | } //AggregationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ArgumentImpl.java index 7c2ae07d..d8bf8d91 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ArgumentImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -7,24 +7,24 @@ import org.eclipse.emf.ecore.EClass; | |||
| 7 | 7 | ||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; |
| 9 | 9 | ||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | 10 | import org.eclipse.viatra.solver.language.solverLanguage.Argument; |
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 12 | 12 | ||
| 13 | /** | 13 | /** |
| 14 | * <!-- begin-user-doc --> | 14 | * <!-- begin-user-doc --> |
| 15 | * An implementation of the model object '<em><b>Polarity</b></em>'. | 15 | * An implementation of the model object '<em><b>Argument</b></em>'. |
| 16 | * <!-- end-user-doc --> | 16 | * <!-- end-user-doc --> |
| 17 | * | 17 | * |
| 18 | * @generated | 18 | * @generated |
| 19 | */ | 19 | */ |
| 20 | public class PolarityImpl extends MinimalEObjectImpl.Container implements Polarity | 20 | public class ArgumentImpl extends MinimalEObjectImpl.Container implements Argument |
| 21 | { | 21 | { |
| 22 | /** | 22 | /** |
| 23 | * <!-- begin-user-doc --> | 23 | * <!-- begin-user-doc --> |
| 24 | * <!-- end-user-doc --> | 24 | * <!-- end-user-doc --> |
| 25 | * @generated | 25 | * @generated |
| 26 | */ | 26 | */ |
| 27 | protected PolarityImpl() | 27 | protected ArgumentImpl() |
| 28 | { | 28 | { |
| 29 | super(); | 29 | super(); |
| 30 | } | 30 | } |
| @@ -37,7 +37,7 @@ public class PolarityImpl extends MinimalEObjectImpl.Container implements Polari | |||
| 37 | @Override | 37 | @Override |
| 38 | protected EClass eStaticClass() | 38 | protected EClass eStaticClass() |
| 39 | { | 39 | { |
| 40 | return SolverLanguagePackage.Literals.POLARITY; | 40 | return SolverLanguagePackage.Literals.ARGUMENT; |
| 41 | } | 41 | } |
| 42 | 42 | ||
| 43 | } //PolarityImpl | 43 | } //ArgumentImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ArgumentListImpl.java index 5cd03fbf..8c16fb4f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ArgumentListImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -17,41 +17,41 @@ import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | |||
| 17 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | 17 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; |
| 18 | import org.eclipse.emf.ecore.util.InternalEList; | 18 | import org.eclipse.emf.ecore.util.InternalEList; |
| 19 | 19 | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | 20 | import org.eclipse.viatra.solver.language.solverLanguage.Argument; |
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | 21 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; |
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 22 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 23 | 23 | ||
| 24 | /** | 24 | /** |
| 25 | * <!-- begin-user-doc --> | 25 | * <!-- begin-user-doc --> |
| 26 | * An implementation of the model object '<em><b>Pattern Body</b></em>'. | 26 | * An implementation of the model object '<em><b>Argument List</b></em>'. |
| 27 | * <!-- end-user-doc --> | 27 | * <!-- end-user-doc --> |
| 28 | * <p> | 28 | * <p> |
| 29 | * The following features are implemented: | 29 | * The following features are implemented: |
| 30 | * </p> | 30 | * </p> |
| 31 | * <ul> | 31 | * <ul> |
| 32 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl#getConstraints <em>Constraints</em>}</li> | 32 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ArgumentListImpl#getArguments <em>Arguments</em>}</li> |
| 33 | * </ul> | 33 | * </ul> |
| 34 | * | 34 | * |
| 35 | * @generated | 35 | * @generated |
| 36 | */ | 36 | */ |
| 37 | public class PatternBodyImpl extends MinimalEObjectImpl.Container implements PatternBody | 37 | public class ArgumentListImpl extends MinimalEObjectImpl.Container implements ArgumentList |
| 38 | { | 38 | { |
| 39 | /** | 39 | /** |
| 40 | * The cached value of the '{@link #getConstraints() <em>Constraints</em>}' containment reference list. | 40 | * The cached value of the '{@link #getArguments() <em>Arguments</em>}' containment reference list. |
| 41 | * <!-- begin-user-doc --> | 41 | * <!-- begin-user-doc --> |
| 42 | * <!-- end-user-doc --> | 42 | * <!-- end-user-doc --> |
| 43 | * @see #getConstraints() | 43 | * @see #getArguments() |
| 44 | * @generated | 44 | * @generated |
| 45 | * @ordered | 45 | * @ordered |
| 46 | */ | 46 | */ |
| 47 | protected EList<Constraint> constraints; | 47 | protected EList<Argument> arguments; |
| 48 | 48 | ||
| 49 | /** | 49 | /** |
| 50 | * <!-- begin-user-doc --> | 50 | * <!-- begin-user-doc --> |
| 51 | * <!-- end-user-doc --> | 51 | * <!-- end-user-doc --> |
| 52 | * @generated | 52 | * @generated |
| 53 | */ | 53 | */ |
| 54 | protected PatternBodyImpl() | 54 | protected ArgumentListImpl() |
| 55 | { | 55 | { |
| 56 | super(); | 56 | super(); |
| 57 | } | 57 | } |
| @@ -64,7 +64,7 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 64 | @Override | 64 | @Override |
| 65 | protected EClass eStaticClass() | 65 | protected EClass eStaticClass() |
| 66 | { | 66 | { |
| 67 | return SolverLanguagePackage.Literals.PATTERN_BODY; | 67 | return SolverLanguagePackage.Literals.ARGUMENT_LIST; |
| 68 | } | 68 | } |
| 69 | 69 | ||
| 70 | /** | 70 | /** |
| @@ -73,13 +73,13 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 73 | * @generated | 73 | * @generated |
| 74 | */ | 74 | */ |
| 75 | @Override | 75 | @Override |
| 76 | public EList<Constraint> getConstraints() | 76 | public EList<Argument> getArguments() |
| 77 | { | 77 | { |
| 78 | if (constraints == null) | 78 | if (arguments == null) |
| 79 | { | 79 | { |
| 80 | constraints = new EObjectContainmentEList<Constraint>(Constraint.class, this, SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS); | 80 | arguments = new EObjectContainmentEList<Argument>(Argument.class, this, SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS); |
| 81 | } | 81 | } |
| 82 | return constraints; | 82 | return arguments; |
| 83 | } | 83 | } |
| 84 | 84 | ||
| 85 | /** | 85 | /** |
| @@ -92,8 +92,8 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 92 | { | 92 | { |
| 93 | switch (featureID) | 93 | switch (featureID) |
| 94 | { | 94 | { |
| 95 | case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: | 95 | case SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS: |
| 96 | return ((InternalEList<?>)getConstraints()).basicRemove(otherEnd, msgs); | 96 | return ((InternalEList<?>)getArguments()).basicRemove(otherEnd, msgs); |
| 97 | } | 97 | } |
| 98 | return super.eInverseRemove(otherEnd, featureID, msgs); | 98 | return super.eInverseRemove(otherEnd, featureID, msgs); |
| 99 | } | 99 | } |
| @@ -108,8 +108,8 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 108 | { | 108 | { |
| 109 | switch (featureID) | 109 | switch (featureID) |
| 110 | { | 110 | { |
| 111 | case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: | 111 | case SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS: |
| 112 | return getConstraints(); | 112 | return getArguments(); |
| 113 | } | 113 | } |
| 114 | return super.eGet(featureID, resolve, coreType); | 114 | return super.eGet(featureID, resolve, coreType); |
| 115 | } | 115 | } |
| @@ -125,9 +125,9 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 125 | { | 125 | { |
| 126 | switch (featureID) | 126 | switch (featureID) |
| 127 | { | 127 | { |
| 128 | case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: | 128 | case SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS: |
| 129 | getConstraints().clear(); | 129 | getArguments().clear(); |
| 130 | getConstraints().addAll((Collection<? extends Constraint>)newValue); | 130 | getArguments().addAll((Collection<? extends Argument>)newValue); |
| 131 | return; | 131 | return; |
| 132 | } | 132 | } |
| 133 | super.eSet(featureID, newValue); | 133 | super.eSet(featureID, newValue); |
| @@ -143,8 +143,8 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 143 | { | 143 | { |
| 144 | switch (featureID) | 144 | switch (featureID) |
| 145 | { | 145 | { |
| 146 | case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: | 146 | case SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS: |
| 147 | getConstraints().clear(); | 147 | getArguments().clear(); |
| 148 | return; | 148 | return; |
| 149 | } | 149 | } |
| 150 | super.eUnset(featureID); | 150 | super.eUnset(featureID); |
| @@ -160,10 +160,10 @@ public class PatternBodyImpl extends MinimalEObjectImpl.Container implements Pat | |||
| 160 | { | 160 | { |
| 161 | switch (featureID) | 161 | switch (featureID) |
| 162 | { | 162 | { |
| 163 | case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: | 163 | case SolverLanguagePackage.ARGUMENT_LIST__ARGUMENTS: |
| 164 | return constraints != null && !constraints.isEmpty(); | 164 | return arguments != null && !arguments.isEmpty(); |
| 165 | } | 165 | } |
| 166 | return super.eIsSet(featureID); | 166 | return super.eIsSet(featureID); |
| 167 | } | 167 | } |
| 168 | 168 | ||
| 169 | } //PatternBodyImpl | 169 | } //ArgumentListImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AssertionImpl.java index 6281c4bc..8165b62e 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AssertionImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -10,55 +10,53 @@ import org.eclipse.emf.ecore.EClass; | |||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | 10 | import org.eclipse.emf.ecore.InternalEObject; |
| 11 | 11 | ||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 13 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 14 | 13 | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 19 | 17 | ||
| 20 | /** | 18 | /** |
| 21 | * <!-- begin-user-doc --> | 19 | * <!-- begin-user-doc --> |
| 22 | * An implementation of the model object '<em><b>Parameter</b></em>'. | 20 | * An implementation of the model object '<em><b>Assertion</b></em>'. |
| 23 | * <!-- end-user-doc --> | 21 | * <!-- end-user-doc --> |
| 24 | * <p> | 22 | * <p> |
| 25 | * The following features are implemented: | 23 | * The following features are implemented: |
| 26 | * </p> | 24 | * </p> |
| 27 | * <ul> | 25 | * <ul> |
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getVariable <em>Variable</em>}</li> | 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl#getBody <em>Body</em>}</li> |
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getType <em>Type</em>}</li> | 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AssertionImpl#getRange <em>Range</em>}</li> |
| 30 | * </ul> | 28 | * </ul> |
| 31 | * | 29 | * |
| 32 | * @generated | 30 | * @generated |
| 33 | */ | 31 | */ |
| 34 | public class ParameterImpl extends MinimalEObjectImpl.Container implements Parameter | 32 | public class AssertionImpl extends StatementImpl implements Assertion |
| 35 | { | 33 | { |
| 36 | /** | 34 | /** |
| 37 | * The cached value of the '{@link #getVariable() <em>Variable</em>}' containment reference. | 35 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. |
| 38 | * <!-- begin-user-doc --> | 36 | * <!-- begin-user-doc --> |
| 39 | * <!-- end-user-doc --> | 37 | * <!-- end-user-doc --> |
| 40 | * @see #getVariable() | 38 | * @see #getBody() |
| 41 | * @generated | 39 | * @generated |
| 42 | * @ordered | 40 | * @ordered |
| 43 | */ | 41 | */ |
| 44 | protected Variable variable; | 42 | protected Expression body; |
| 45 | 43 | ||
| 46 | /** | 44 | /** |
| 47 | * The cached value of the '{@link #getType() <em>Type</em>}' containment reference. | 45 | * The cached value of the '{@link #getRange() <em>Range</em>}' containment reference. |
| 48 | * <!-- begin-user-doc --> | 46 | * <!-- begin-user-doc --> |
| 49 | * <!-- end-user-doc --> | 47 | * <!-- end-user-doc --> |
| 50 | * @see #getType() | 48 | * @see #getRange() |
| 51 | * @generated | 49 | * @generated |
| 52 | * @ordered | 50 | * @ordered |
| 53 | */ | 51 | */ |
| 54 | protected Symbol type; | 52 | protected Expression range; |
| 55 | 53 | ||
| 56 | /** | 54 | /** |
| 57 | * <!-- begin-user-doc --> | 55 | * <!-- begin-user-doc --> |
| 58 | * <!-- end-user-doc --> | 56 | * <!-- end-user-doc --> |
| 59 | * @generated | 57 | * @generated |
| 60 | */ | 58 | */ |
| 61 | protected ParameterImpl() | 59 | protected AssertionImpl() |
| 62 | { | 60 | { |
| 63 | super(); | 61 | super(); |
| 64 | } | 62 | } |
| @@ -71,7 +69,7 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 71 | @Override | 69 | @Override |
| 72 | protected EClass eStaticClass() | 70 | protected EClass eStaticClass() |
| 73 | { | 71 | { |
| 74 | return SolverLanguagePackage.Literals.PARAMETER; | 72 | return SolverLanguagePackage.Literals.ASSERTION; |
| 75 | } | 73 | } |
| 76 | 74 | ||
| 77 | /** | 75 | /** |
| @@ -80,9 +78,9 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 80 | * @generated | 78 | * @generated |
| 81 | */ | 79 | */ |
| 82 | @Override | 80 | @Override |
| 83 | public Variable getVariable() | 81 | public Expression getBody() |
| 84 | { | 82 | { |
| 85 | return variable; | 83 | return body; |
| 86 | } | 84 | } |
| 87 | 85 | ||
| 88 | /** | 86 | /** |
| @@ -90,13 +88,13 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 90 | * <!-- end-user-doc --> | 88 | * <!-- end-user-doc --> |
| 91 | * @generated | 89 | * @generated |
| 92 | */ | 90 | */ |
| 93 | public NotificationChain basicSetVariable(Variable newVariable, NotificationChain msgs) | 91 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) |
| 94 | { | 92 | { |
| 95 | Variable oldVariable = variable; | 93 | Expression oldBody = body; |
| 96 | variable = newVariable; | 94 | body = newBody; |
| 97 | if (eNotificationRequired()) | 95 | if (eNotificationRequired()) |
| 98 | { | 96 | { |
| 99 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, oldVariable, newVariable); | 97 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ASSERTION__BODY, oldBody, newBody); |
| 100 | if (msgs == null) msgs = notification; else msgs.add(notification); | 98 | if (msgs == null) msgs = notification; else msgs.add(notification); |
| 101 | } | 99 | } |
| 102 | return msgs; | 100 | return msgs; |
| @@ -108,20 +106,20 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 108 | * @generated | 106 | * @generated |
| 109 | */ | 107 | */ |
| 110 | @Override | 108 | @Override |
| 111 | public void setVariable(Variable newVariable) | 109 | public void setBody(Expression newBody) |
| 112 | { | 110 | { |
| 113 | if (newVariable != variable) | 111 | if (newBody != body) |
| 114 | { | 112 | { |
| 115 | NotificationChain msgs = null; | 113 | NotificationChain msgs = null; |
| 116 | if (variable != null) | 114 | if (body != null) |
| 117 | msgs = ((InternalEObject)variable).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs); | 115 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ASSERTION__BODY, null, msgs); |
| 118 | if (newVariable != null) | 116 | if (newBody != null) |
| 119 | msgs = ((InternalEObject)newVariable).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs); | 117 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ASSERTION__BODY, null, msgs); |
| 120 | msgs = basicSetVariable(newVariable, msgs); | 118 | msgs = basicSetBody(newBody, msgs); |
| 121 | if (msgs != null) msgs.dispatch(); | 119 | if (msgs != null) msgs.dispatch(); |
| 122 | } | 120 | } |
| 123 | else if (eNotificationRequired()) | 121 | else if (eNotificationRequired()) |
| 124 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, newVariable, newVariable)); | 122 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ASSERTION__BODY, newBody, newBody)); |
| 125 | } | 123 | } |
| 126 | 124 | ||
| 127 | /** | 125 | /** |
| @@ -130,9 +128,9 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 130 | * @generated | 128 | * @generated |
| 131 | */ | 129 | */ |
| 132 | @Override | 130 | @Override |
| 133 | public Symbol getType() | 131 | public Expression getRange() |
| 134 | { | 132 | { |
| 135 | return type; | 133 | return range; |
| 136 | } | 134 | } |
| 137 | 135 | ||
| 138 | /** | 136 | /** |
| @@ -140,13 +138,13 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 140 | * <!-- end-user-doc --> | 138 | * <!-- end-user-doc --> |
| 141 | * @generated | 139 | * @generated |
| 142 | */ | 140 | */ |
| 143 | public NotificationChain basicSetType(Symbol newType, NotificationChain msgs) | 141 | public NotificationChain basicSetRange(Expression newRange, NotificationChain msgs) |
| 144 | { | 142 | { |
| 145 | Symbol oldType = type; | 143 | Expression oldRange = range; |
| 146 | type = newType; | 144 | range = newRange; |
| 147 | if (eNotificationRequired()) | 145 | if (eNotificationRequired()) |
| 148 | { | 146 | { |
| 149 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, oldType, newType); | 147 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ASSERTION__RANGE, oldRange, newRange); |
| 150 | if (msgs == null) msgs = notification; else msgs.add(notification); | 148 | if (msgs == null) msgs = notification; else msgs.add(notification); |
| 151 | } | 149 | } |
| 152 | return msgs; | 150 | return msgs; |
| @@ -158,20 +156,20 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 158 | * @generated | 156 | * @generated |
| 159 | */ | 157 | */ |
| 160 | @Override | 158 | @Override |
| 161 | public void setType(Symbol newType) | 159 | public void setRange(Expression newRange) |
| 162 | { | 160 | { |
| 163 | if (newType != type) | 161 | if (newRange != range) |
| 164 | { | 162 | { |
| 165 | NotificationChain msgs = null; | 163 | NotificationChain msgs = null; |
| 166 | if (type != null) | 164 | if (range != null) |
| 167 | msgs = ((InternalEObject)type).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs); | 165 | msgs = ((InternalEObject)range).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ASSERTION__RANGE, null, msgs); |
| 168 | if (newType != null) | 166 | if (newRange != null) |
| 169 | msgs = ((InternalEObject)newType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs); | 167 | msgs = ((InternalEObject)newRange).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ASSERTION__RANGE, null, msgs); |
| 170 | msgs = basicSetType(newType, msgs); | 168 | msgs = basicSetRange(newRange, msgs); |
| 171 | if (msgs != null) msgs.dispatch(); | 169 | if (msgs != null) msgs.dispatch(); |
| 172 | } | 170 | } |
| 173 | else if (eNotificationRequired()) | 171 | else if (eNotificationRequired()) |
| 174 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, newType, newType)); | 172 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ASSERTION__RANGE, newRange, newRange)); |
| 175 | } | 173 | } |
| 176 | 174 | ||
| 177 | /** | 175 | /** |
| @@ -184,10 +182,10 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 184 | { | 182 | { |
| 185 | switch (featureID) | 183 | switch (featureID) |
| 186 | { | 184 | { |
| 187 | case SolverLanguagePackage.PARAMETER__VARIABLE: | 185 | case SolverLanguagePackage.ASSERTION__BODY: |
| 188 | return basicSetVariable(null, msgs); | 186 | return basicSetBody(null, msgs); |
| 189 | case SolverLanguagePackage.PARAMETER__TYPE: | 187 | case SolverLanguagePackage.ASSERTION__RANGE: |
| 190 | return basicSetType(null, msgs); | 188 | return basicSetRange(null, msgs); |
| 191 | } | 189 | } |
| 192 | return super.eInverseRemove(otherEnd, featureID, msgs); | 190 | return super.eInverseRemove(otherEnd, featureID, msgs); |
| 193 | } | 191 | } |
| @@ -202,10 +200,10 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 202 | { | 200 | { |
| 203 | switch (featureID) | 201 | switch (featureID) |
| 204 | { | 202 | { |
| 205 | case SolverLanguagePackage.PARAMETER__VARIABLE: | 203 | case SolverLanguagePackage.ASSERTION__BODY: |
| 206 | return getVariable(); | 204 | return getBody(); |
| 207 | case SolverLanguagePackage.PARAMETER__TYPE: | 205 | case SolverLanguagePackage.ASSERTION__RANGE: |
| 208 | return getType(); | 206 | return getRange(); |
| 209 | } | 207 | } |
| 210 | return super.eGet(featureID, resolve, coreType); | 208 | return super.eGet(featureID, resolve, coreType); |
| 211 | } | 209 | } |
| @@ -220,11 +218,11 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 220 | { | 218 | { |
| 221 | switch (featureID) | 219 | switch (featureID) |
| 222 | { | 220 | { |
| 223 | case SolverLanguagePackage.PARAMETER__VARIABLE: | 221 | case SolverLanguagePackage.ASSERTION__BODY: |
| 224 | setVariable((Variable)newValue); | 222 | setBody((Expression)newValue); |
| 225 | return; | 223 | return; |
| 226 | case SolverLanguagePackage.PARAMETER__TYPE: | 224 | case SolverLanguagePackage.ASSERTION__RANGE: |
| 227 | setType((Symbol)newValue); | 225 | setRange((Expression)newValue); |
| 228 | return; | 226 | return; |
| 229 | } | 227 | } |
| 230 | super.eSet(featureID, newValue); | 228 | super.eSet(featureID, newValue); |
| @@ -240,11 +238,11 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 240 | { | 238 | { |
| 241 | switch (featureID) | 239 | switch (featureID) |
| 242 | { | 240 | { |
| 243 | case SolverLanguagePackage.PARAMETER__VARIABLE: | 241 | case SolverLanguagePackage.ASSERTION__BODY: |
| 244 | setVariable((Variable)null); | 242 | setBody((Expression)null); |
| 245 | return; | 243 | return; |
| 246 | case SolverLanguagePackage.PARAMETER__TYPE: | 244 | case SolverLanguagePackage.ASSERTION__RANGE: |
| 247 | setType((Symbol)null); | 245 | setRange((Expression)null); |
| 248 | return; | 246 | return; |
| 249 | } | 247 | } |
| 250 | super.eUnset(featureID); | 248 | super.eUnset(featureID); |
| @@ -260,12 +258,12 @@ public class ParameterImpl extends MinimalEObjectImpl.Container implements Param | |||
| 260 | { | 258 | { |
| 261 | switch (featureID) | 259 | switch (featureID) |
| 262 | { | 260 | { |
| 263 | case SolverLanguagePackage.PARAMETER__VARIABLE: | 261 | case SolverLanguagePackage.ASSERTION__BODY: |
| 264 | return variable != null; | 262 | return body != null; |
| 265 | case SolverLanguagePackage.PARAMETER__TYPE: | 263 | case SolverLanguagePackage.ASSERTION__RANGE: |
| 266 | return type != null; | 264 | return range != null; |
| 267 | } | 265 | } |
| 268 | return super.eIsSet(featureID); | 266 | return super.eIsSet(featureID); |
| 269 | } | 267 | } |
| 270 | 268 | ||
| 271 | } //ParameterImpl | 269 | } //AssertionImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java deleted file mode 100644 index aef515f6..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java +++ /dev/null | |||
| @@ -1,318 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | |||
| 18 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 19 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 20 | |||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | ||
| 26 | |||
| 27 | /** | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * An implementation of the model object '<em><b>Basic Interpretation</b></em>'. | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * <p> | ||
| 32 | * The following features are implemented: | ||
| 33 | * </p> | ||
| 34 | * <ul> | ||
| 35 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getSymbol <em>Symbol</em>}</li> | ||
| 36 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getObjects <em>Objects</em>}</li> | ||
| 37 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getValue <em>Value</em>}</li> | ||
| 38 | * </ul> | ||
| 39 | * | ||
| 40 | * @generated | ||
| 41 | */ | ||
| 42 | public class BasicInterpretationImpl extends InterpretationImpl implements BasicInterpretation | ||
| 43 | { | ||
| 44 | /** | ||
| 45 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 46 | * <!-- begin-user-doc --> | ||
| 47 | * <!-- end-user-doc --> | ||
| 48 | * @see #getSymbol() | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | protected Symbol symbol; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * The cached value of the '{@link #getObjects() <em>Objects</em>}' containment reference list. | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @see #getObjects() | ||
| 59 | * @generated | ||
| 60 | * @ordered | ||
| 61 | */ | ||
| 62 | protected EList<ComplexObject> objects; | ||
| 63 | |||
| 64 | /** | ||
| 65 | * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference. | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @see #getValue() | ||
| 69 | * @generated | ||
| 70 | * @ordered | ||
| 71 | */ | ||
| 72 | protected TruthValue value; | ||
| 73 | |||
| 74 | /** | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @generated | ||
| 78 | */ | ||
| 79 | protected BasicInterpretationImpl() | ||
| 80 | { | ||
| 81 | super(); | ||
| 82 | } | ||
| 83 | |||
| 84 | /** | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @generated | ||
| 88 | */ | ||
| 89 | @Override | ||
| 90 | protected EClass eStaticClass() | ||
| 91 | { | ||
| 92 | return SolverLanguagePackage.Literals.BASIC_INTERPRETATION; | ||
| 93 | } | ||
| 94 | |||
| 95 | /** | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @generated | ||
| 99 | */ | ||
| 100 | @Override | ||
| 101 | public Symbol getSymbol() | ||
| 102 | { | ||
| 103 | return symbol; | ||
| 104 | } | ||
| 105 | |||
| 106 | /** | ||
| 107 | * <!-- begin-user-doc --> | ||
| 108 | * <!-- end-user-doc --> | ||
| 109 | * @generated | ||
| 110 | */ | ||
| 111 | public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs) | ||
| 112 | { | ||
| 113 | Symbol oldSymbol = symbol; | ||
| 114 | symbol = newSymbol; | ||
| 115 | if (eNotificationRequired()) | ||
| 116 | { | ||
| 117 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); | ||
| 118 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 119 | } | ||
| 120 | return msgs; | ||
| 121 | } | ||
| 122 | |||
| 123 | /** | ||
| 124 | * <!-- begin-user-doc --> | ||
| 125 | * <!-- end-user-doc --> | ||
| 126 | * @generated | ||
| 127 | */ | ||
| 128 | @Override | ||
| 129 | public void setSymbol(Symbol newSymbol) | ||
| 130 | { | ||
| 131 | if (newSymbol != symbol) | ||
| 132 | { | ||
| 133 | NotificationChain msgs = null; | ||
| 134 | if (symbol != null) | ||
| 135 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs); | ||
| 136 | if (newSymbol != null) | ||
| 137 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs); | ||
| 138 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 139 | if (msgs != null) msgs.dispatch(); | ||
| 140 | } | ||
| 141 | else if (eNotificationRequired()) | ||
| 142 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); | ||
| 143 | } | ||
| 144 | |||
| 145 | /** | ||
| 146 | * <!-- begin-user-doc --> | ||
| 147 | * <!-- end-user-doc --> | ||
| 148 | * @generated | ||
| 149 | */ | ||
| 150 | @Override | ||
| 151 | public EList<ComplexObject> getObjects() | ||
| 152 | { | ||
| 153 | if (objects == null) | ||
| 154 | { | ||
| 155 | objects = new EObjectContainmentEList<ComplexObject>(ComplexObject.class, this, SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS); | ||
| 156 | } | ||
| 157 | return objects; | ||
| 158 | } | ||
| 159 | |||
| 160 | /** | ||
| 161 | * <!-- begin-user-doc --> | ||
| 162 | * <!-- end-user-doc --> | ||
| 163 | * @generated | ||
| 164 | */ | ||
| 165 | @Override | ||
| 166 | public TruthValue getValue() | ||
| 167 | { | ||
| 168 | return value; | ||
| 169 | } | ||
| 170 | |||
| 171 | /** | ||
| 172 | * <!-- begin-user-doc --> | ||
| 173 | * <!-- end-user-doc --> | ||
| 174 | * @generated | ||
| 175 | */ | ||
| 176 | public NotificationChain basicSetValue(TruthValue newValue, NotificationChain msgs) | ||
| 177 | { | ||
| 178 | TruthValue oldValue = value; | ||
| 179 | value = newValue; | ||
| 180 | if (eNotificationRequired()) | ||
| 181 | { | ||
| 182 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, oldValue, newValue); | ||
| 183 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 184 | } | ||
| 185 | return msgs; | ||
| 186 | } | ||
| 187 | |||
| 188 | /** | ||
| 189 | * <!-- begin-user-doc --> | ||
| 190 | * <!-- end-user-doc --> | ||
| 191 | * @generated | ||
| 192 | */ | ||
| 193 | @Override | ||
| 194 | public void setValue(TruthValue newValue) | ||
| 195 | { | ||
| 196 | if (newValue != value) | ||
| 197 | { | ||
| 198 | NotificationChain msgs = null; | ||
| 199 | if (value != null) | ||
| 200 | msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs); | ||
| 201 | if (newValue != null) | ||
| 202 | msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs); | ||
| 203 | msgs = basicSetValue(newValue, msgs); | ||
| 204 | if (msgs != null) msgs.dispatch(); | ||
| 205 | } | ||
| 206 | else if (eNotificationRequired()) | ||
| 207 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, newValue, newValue)); | ||
| 208 | } | ||
| 209 | |||
| 210 | /** | ||
| 211 | * <!-- begin-user-doc --> | ||
| 212 | * <!-- end-user-doc --> | ||
| 213 | * @generated | ||
| 214 | */ | ||
| 215 | @Override | ||
| 216 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 217 | { | ||
| 218 | switch (featureID) | ||
| 219 | { | ||
| 220 | case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: | ||
| 221 | return basicSetSymbol(null, msgs); | ||
| 222 | case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: | ||
| 223 | return ((InternalEList<?>)getObjects()).basicRemove(otherEnd, msgs); | ||
| 224 | case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: | ||
| 225 | return basicSetValue(null, msgs); | ||
| 226 | } | ||
| 227 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 228 | } | ||
| 229 | |||
| 230 | /** | ||
| 231 | * <!-- begin-user-doc --> | ||
| 232 | * <!-- end-user-doc --> | ||
| 233 | * @generated | ||
| 234 | */ | ||
| 235 | @Override | ||
| 236 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 237 | { | ||
| 238 | switch (featureID) | ||
| 239 | { | ||
| 240 | case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: | ||
| 241 | return getSymbol(); | ||
| 242 | case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: | ||
| 243 | return getObjects(); | ||
| 244 | case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: | ||
| 245 | return getValue(); | ||
| 246 | } | ||
| 247 | return super.eGet(featureID, resolve, coreType); | ||
| 248 | } | ||
| 249 | |||
| 250 | /** | ||
| 251 | * <!-- begin-user-doc --> | ||
| 252 | * <!-- end-user-doc --> | ||
| 253 | * @generated | ||
| 254 | */ | ||
| 255 | @SuppressWarnings("unchecked") | ||
| 256 | @Override | ||
| 257 | public void eSet(int featureID, Object newValue) | ||
| 258 | { | ||
| 259 | switch (featureID) | ||
| 260 | { | ||
| 261 | case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: | ||
| 262 | setSymbol((Symbol)newValue); | ||
| 263 | return; | ||
| 264 | case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: | ||
| 265 | getObjects().clear(); | ||
| 266 | getObjects().addAll((Collection<? extends ComplexObject>)newValue); | ||
| 267 | return; | ||
| 268 | case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: | ||
| 269 | setValue((TruthValue)newValue); | ||
| 270 | return; | ||
| 271 | } | ||
| 272 | super.eSet(featureID, newValue); | ||
| 273 | } | ||
| 274 | |||
| 275 | /** | ||
| 276 | * <!-- begin-user-doc --> | ||
| 277 | * <!-- end-user-doc --> | ||
| 278 | * @generated | ||
| 279 | */ | ||
| 280 | @Override | ||
| 281 | public void eUnset(int featureID) | ||
| 282 | { | ||
| 283 | switch (featureID) | ||
| 284 | { | ||
| 285 | case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: | ||
| 286 | setSymbol((Symbol)null); | ||
| 287 | return; | ||
| 288 | case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: | ||
| 289 | getObjects().clear(); | ||
| 290 | return; | ||
| 291 | case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: | ||
| 292 | setValue((TruthValue)null); | ||
| 293 | return; | ||
| 294 | } | ||
| 295 | super.eUnset(featureID); | ||
| 296 | } | ||
| 297 | |||
| 298 | /** | ||
| 299 | * <!-- begin-user-doc --> | ||
| 300 | * <!-- end-user-doc --> | ||
| 301 | * @generated | ||
| 302 | */ | ||
| 303 | @Override | ||
| 304 | public boolean eIsSet(int featureID) | ||
| 305 | { | ||
| 306 | switch (featureID) | ||
| 307 | { | ||
| 308 | case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: | ||
| 309 | return symbol != null; | ||
| 310 | case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: | ||
| 311 | return objects != null && !objects.isEmpty(); | ||
| 312 | case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: | ||
| 313 | return value != null; | ||
| 314 | } | ||
| 315 | return super.eIsSet(featureID); | ||
| 316 | } | ||
| 317 | |||
| 318 | } //BasicInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BinaryExpressionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BinaryExpressionImpl.java new file mode 100644 index 00000000..adc94c4a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BinaryExpressionImpl.java | |||
| @@ -0,0 +1,343 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Binary Expression</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl#getLeft <em>Left</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl#getOp <em>Op</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BinaryExpressionImpl#getRight <em>Right</em>}</li> | ||
| 30 | * </ul> | ||
| 31 | * | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | public class BinaryExpressionImpl extends ExpressionImpl implements BinaryExpression | ||
| 35 | { | ||
| 36 | /** | ||
| 37 | * The cached value of the '{@link #getLeft() <em>Left</em>}' containment reference. | ||
| 38 | * <!-- begin-user-doc --> | ||
| 39 | * <!-- end-user-doc --> | ||
| 40 | * @see #getLeft() | ||
| 41 | * @generated | ||
| 42 | * @ordered | ||
| 43 | */ | ||
| 44 | protected Expression left; | ||
| 45 | |||
| 46 | /** | ||
| 47 | * The default value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @see #getOp() | ||
| 51 | * @generated | ||
| 52 | * @ordered | ||
| 53 | */ | ||
| 54 | protected static final BinaryOperator OP_EDEFAULT = BinaryOperator.EQ; | ||
| 55 | |||
| 56 | /** | ||
| 57 | * The cached value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @see #getOp() | ||
| 61 | * @generated | ||
| 62 | * @ordered | ||
| 63 | */ | ||
| 64 | protected BinaryOperator op = OP_EDEFAULT; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * The cached value of the '{@link #getRight() <em>Right</em>}' containment reference. | ||
| 68 | * <!-- begin-user-doc --> | ||
| 69 | * <!-- end-user-doc --> | ||
| 70 | * @see #getRight() | ||
| 71 | * @generated | ||
| 72 | * @ordered | ||
| 73 | */ | ||
| 74 | protected Expression right; | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | protected BinaryExpressionImpl() | ||
| 82 | { | ||
| 83 | super(); | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | protected EClass eStaticClass() | ||
| 93 | { | ||
| 94 | return SolverLanguagePackage.Literals.BINARY_EXPRESSION; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public Expression getLeft() | ||
| 104 | { | ||
| 105 | return left; | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | public NotificationChain basicSetLeft(Expression newLeft, NotificationChain msgs) | ||
| 114 | { | ||
| 115 | Expression oldLeft = left; | ||
| 116 | left = newLeft; | ||
| 117 | if (eNotificationRequired()) | ||
| 118 | { | ||
| 119 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BINARY_EXPRESSION__LEFT, oldLeft, newLeft); | ||
| 120 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 121 | } | ||
| 122 | return msgs; | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void setLeft(Expression newLeft) | ||
| 132 | { | ||
| 133 | if (newLeft != left) | ||
| 134 | { | ||
| 135 | NotificationChain msgs = null; | ||
| 136 | if (left != null) | ||
| 137 | msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BINARY_EXPRESSION__LEFT, null, msgs); | ||
| 138 | if (newLeft != null) | ||
| 139 | msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BINARY_EXPRESSION__LEFT, null, msgs); | ||
| 140 | msgs = basicSetLeft(newLeft, msgs); | ||
| 141 | if (msgs != null) msgs.dispatch(); | ||
| 142 | } | ||
| 143 | else if (eNotificationRequired()) | ||
| 144 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BINARY_EXPRESSION__LEFT, newLeft, newLeft)); | ||
| 145 | } | ||
| 146 | |||
| 147 | /** | ||
| 148 | * <!-- begin-user-doc --> | ||
| 149 | * <!-- end-user-doc --> | ||
| 150 | * @generated | ||
| 151 | */ | ||
| 152 | @Override | ||
| 153 | public BinaryOperator getOp() | ||
| 154 | { | ||
| 155 | return op; | ||
| 156 | } | ||
| 157 | |||
| 158 | /** | ||
| 159 | * <!-- begin-user-doc --> | ||
| 160 | * <!-- end-user-doc --> | ||
| 161 | * @generated | ||
| 162 | */ | ||
| 163 | @Override | ||
| 164 | public void setOp(BinaryOperator newOp) | ||
| 165 | { | ||
| 166 | BinaryOperator oldOp = op; | ||
| 167 | op = newOp == null ? OP_EDEFAULT : newOp; | ||
| 168 | if (eNotificationRequired()) | ||
| 169 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BINARY_EXPRESSION__OP, oldOp, op)); | ||
| 170 | } | ||
| 171 | |||
| 172 | /** | ||
| 173 | * <!-- begin-user-doc --> | ||
| 174 | * <!-- end-user-doc --> | ||
| 175 | * @generated | ||
| 176 | */ | ||
| 177 | @Override | ||
| 178 | public Expression getRight() | ||
| 179 | { | ||
| 180 | return right; | ||
| 181 | } | ||
| 182 | |||
| 183 | /** | ||
| 184 | * <!-- begin-user-doc --> | ||
| 185 | * <!-- end-user-doc --> | ||
| 186 | * @generated | ||
| 187 | */ | ||
| 188 | public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs) | ||
| 189 | { | ||
| 190 | Expression oldRight = right; | ||
| 191 | right = newRight; | ||
| 192 | if (eNotificationRequired()) | ||
| 193 | { | ||
| 194 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BINARY_EXPRESSION__RIGHT, oldRight, newRight); | ||
| 195 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 196 | } | ||
| 197 | return msgs; | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public void setRight(Expression newRight) | ||
| 207 | { | ||
| 208 | if (newRight != right) | ||
| 209 | { | ||
| 210 | NotificationChain msgs = null; | ||
| 211 | if (right != null) | ||
| 212 | msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BINARY_EXPRESSION__RIGHT, null, msgs); | ||
| 213 | if (newRight != null) | ||
| 214 | msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BINARY_EXPRESSION__RIGHT, null, msgs); | ||
| 215 | msgs = basicSetRight(newRight, msgs); | ||
| 216 | if (msgs != null) msgs.dispatch(); | ||
| 217 | } | ||
| 218 | else if (eNotificationRequired()) | ||
| 219 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BINARY_EXPRESSION__RIGHT, newRight, newRight)); | ||
| 220 | } | ||
| 221 | |||
| 222 | /** | ||
| 223 | * <!-- begin-user-doc --> | ||
| 224 | * <!-- end-user-doc --> | ||
| 225 | * @generated | ||
| 226 | */ | ||
| 227 | @Override | ||
| 228 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 229 | { | ||
| 230 | switch (featureID) | ||
| 231 | { | ||
| 232 | case SolverLanguagePackage.BINARY_EXPRESSION__LEFT: | ||
| 233 | return basicSetLeft(null, msgs); | ||
| 234 | case SolverLanguagePackage.BINARY_EXPRESSION__RIGHT: | ||
| 235 | return basicSetRight(null, msgs); | ||
| 236 | } | ||
| 237 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 238 | } | ||
| 239 | |||
| 240 | /** | ||
| 241 | * <!-- begin-user-doc --> | ||
| 242 | * <!-- end-user-doc --> | ||
| 243 | * @generated | ||
| 244 | */ | ||
| 245 | @Override | ||
| 246 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 247 | { | ||
| 248 | switch (featureID) | ||
| 249 | { | ||
| 250 | case SolverLanguagePackage.BINARY_EXPRESSION__LEFT: | ||
| 251 | return getLeft(); | ||
| 252 | case SolverLanguagePackage.BINARY_EXPRESSION__OP: | ||
| 253 | return getOp(); | ||
| 254 | case SolverLanguagePackage.BINARY_EXPRESSION__RIGHT: | ||
| 255 | return getRight(); | ||
| 256 | } | ||
| 257 | return super.eGet(featureID, resolve, coreType); | ||
| 258 | } | ||
| 259 | |||
| 260 | /** | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | @Override | ||
| 266 | public void eSet(int featureID, Object newValue) | ||
| 267 | { | ||
| 268 | switch (featureID) | ||
| 269 | { | ||
| 270 | case SolverLanguagePackage.BINARY_EXPRESSION__LEFT: | ||
| 271 | setLeft((Expression)newValue); | ||
| 272 | return; | ||
| 273 | case SolverLanguagePackage.BINARY_EXPRESSION__OP: | ||
| 274 | setOp((BinaryOperator)newValue); | ||
| 275 | return; | ||
| 276 | case SolverLanguagePackage.BINARY_EXPRESSION__RIGHT: | ||
| 277 | setRight((Expression)newValue); | ||
| 278 | return; | ||
| 279 | } | ||
| 280 | super.eSet(featureID, newValue); | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public void eUnset(int featureID) | ||
| 290 | { | ||
| 291 | switch (featureID) | ||
| 292 | { | ||
| 293 | case SolverLanguagePackage.BINARY_EXPRESSION__LEFT: | ||
| 294 | setLeft((Expression)null); | ||
| 295 | return; | ||
| 296 | case SolverLanguagePackage.BINARY_EXPRESSION__OP: | ||
| 297 | setOp(OP_EDEFAULT); | ||
| 298 | return; | ||
| 299 | case SolverLanguagePackage.BINARY_EXPRESSION__RIGHT: | ||
| 300 | setRight((Expression)null); | ||
| 301 | return; | ||
| 302 | } | ||
| 303 | super.eUnset(featureID); | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public boolean eIsSet(int featureID) | ||
| 313 | { | ||
| 314 | switch (featureID) | ||
| 315 | { | ||
| 316 | case SolverLanguagePackage.BINARY_EXPRESSION__LEFT: | ||
| 317 | return left != null; | ||
| 318 | case SolverLanguagePackage.BINARY_EXPRESSION__OP: | ||
| 319 | return op != OP_EDEFAULT; | ||
| 320 | case SolverLanguagePackage.BINARY_EXPRESSION__RIGHT: | ||
| 321 | return right != null; | ||
| 322 | } | ||
| 323 | return super.eIsSet(featureID); | ||
| 324 | } | ||
| 325 | |||
| 326 | /** | ||
| 327 | * <!-- begin-user-doc --> | ||
| 328 | * <!-- end-user-doc --> | ||
| 329 | * @generated | ||
| 330 | */ | ||
| 331 | @Override | ||
| 332 | public String toString() | ||
| 333 | { | ||
| 334 | if (eIsProxy()) return super.toString(); | ||
| 335 | |||
| 336 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 337 | result.append(" (op: "); | ||
| 338 | result.append(op); | ||
| 339 | result.append(')'); | ||
| 340 | return result.toString(); | ||
| 341 | } | ||
| 342 | |||
| 343 | } //BinaryExpressionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java deleted file mode 100644 index 49258091..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Boolean Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class BooleanSymbolImpl extends DataSymbolImpl implements BooleanSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected BooleanSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.BOOLEAN_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //BooleanSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java deleted file mode 100644 index 4d110ee9..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Boolean True</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class BooleanTrueImpl extends BooleanValueImpl implements BooleanTrue | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected BooleanTrueImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.BOOLEAN_TRUE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //BooleanTrueImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java deleted file mode 100644 index b27ab959..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java +++ /dev/null | |||
| @@ -1,43 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 9 | |||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | ||
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * <!-- begin-user-doc --> | ||
| 15 | * An implementation of the model object '<em><b>Boolean Value</b></em>'. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * | ||
| 18 | * @generated | ||
| 19 | */ | ||
| 20 | public class BooleanValueImpl extends MinimalEObjectImpl.Container implements BooleanValue | ||
| 21 | { | ||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * <!-- end-user-doc --> | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | protected BooleanValueImpl() | ||
| 28 | { | ||
| 29 | super(); | ||
| 30 | } | ||
| 31 | |||
| 32 | /** | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | @Override | ||
| 38 | protected EClass eStaticClass() | ||
| 39 | { | ||
| 40 | return SolverLanguagePackage.Literals.BOOLEAN_VALUE; | ||
| 41 | } | ||
| 42 | |||
| 43 | } //BooleanValueImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedMultiplicityImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedMultiplicityImpl.java new file mode 100644 index 00000000..45a105e0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedMultiplicityImpl.java | |||
| @@ -0,0 +1,237 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Bounded Multiplicity</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl#getLowerBound <em>Lower Bound</em>}</li> | ||
| 24 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedMultiplicityImpl#getUpperBound <em>Upper Bound</em>}</li> | ||
| 25 | * </ul> | ||
| 26 | * | ||
| 27 | * @generated | ||
| 28 | */ | ||
| 29 | public class BoundedMultiplicityImpl extends MultiplicityImpl implements BoundedMultiplicity | ||
| 30 | { | ||
| 31 | /** | ||
| 32 | * The default value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @see #getLowerBound() | ||
| 36 | * @generated | ||
| 37 | * @ordered | ||
| 38 | */ | ||
| 39 | protected static final int LOWER_BOUND_EDEFAULT = 0; | ||
| 40 | |||
| 41 | /** | ||
| 42 | * The cached value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @see #getLowerBound() | ||
| 46 | * @generated | ||
| 47 | * @ordered | ||
| 48 | */ | ||
| 49 | protected int lowerBound = LOWER_BOUND_EDEFAULT; | ||
| 50 | |||
| 51 | /** | ||
| 52 | * The default value of the '{@link #getUpperBound() <em>Upper Bound</em>}' attribute. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @see #getUpperBound() | ||
| 56 | * @generated | ||
| 57 | * @ordered | ||
| 58 | */ | ||
| 59 | protected static final int UPPER_BOUND_EDEFAULT = 0; | ||
| 60 | |||
| 61 | /** | ||
| 62 | * The cached value of the '{@link #getUpperBound() <em>Upper Bound</em>}' attribute. | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @see #getUpperBound() | ||
| 66 | * @generated | ||
| 67 | * @ordered | ||
| 68 | */ | ||
| 69 | protected int upperBound = UPPER_BOUND_EDEFAULT; | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | protected BoundedMultiplicityImpl() | ||
| 77 | { | ||
| 78 | super(); | ||
| 79 | } | ||
| 80 | |||
| 81 | /** | ||
| 82 | * <!-- begin-user-doc --> | ||
| 83 | * <!-- end-user-doc --> | ||
| 84 | * @generated | ||
| 85 | */ | ||
| 86 | @Override | ||
| 87 | protected EClass eStaticClass() | ||
| 88 | { | ||
| 89 | return SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY; | ||
| 90 | } | ||
| 91 | |||
| 92 | /** | ||
| 93 | * <!-- begin-user-doc --> | ||
| 94 | * <!-- end-user-doc --> | ||
| 95 | * @generated | ||
| 96 | */ | ||
| 97 | @Override | ||
| 98 | public int getLowerBound() | ||
| 99 | { | ||
| 100 | return lowerBound; | ||
| 101 | } | ||
| 102 | |||
| 103 | /** | ||
| 104 | * <!-- begin-user-doc --> | ||
| 105 | * <!-- end-user-doc --> | ||
| 106 | * @generated | ||
| 107 | */ | ||
| 108 | @Override | ||
| 109 | public void setLowerBound(int newLowerBound) | ||
| 110 | { | ||
| 111 | int oldLowerBound = lowerBound; | ||
| 112 | lowerBound = newLowerBound; | ||
| 113 | if (eNotificationRequired()) | ||
| 114 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOUNDED_MULTIPLICITY__LOWER_BOUND, oldLowerBound, lowerBound)); | ||
| 115 | } | ||
| 116 | |||
| 117 | /** | ||
| 118 | * <!-- begin-user-doc --> | ||
| 119 | * <!-- end-user-doc --> | ||
| 120 | * @generated | ||
| 121 | */ | ||
| 122 | @Override | ||
| 123 | public int getUpperBound() | ||
| 124 | { | ||
| 125 | return upperBound; | ||
| 126 | } | ||
| 127 | |||
| 128 | /** | ||
| 129 | * <!-- begin-user-doc --> | ||
| 130 | * <!-- end-user-doc --> | ||
| 131 | * @generated | ||
| 132 | */ | ||
| 133 | @Override | ||
| 134 | public void setUpperBound(int newUpperBound) | ||
| 135 | { | ||
| 136 | int oldUpperBound = upperBound; | ||
| 137 | upperBound = newUpperBound; | ||
| 138 | if (eNotificationRequired()) | ||
| 139 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOUNDED_MULTIPLICITY__UPPER_BOUND, oldUpperBound, upperBound)); | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 149 | { | ||
| 150 | switch (featureID) | ||
| 151 | { | ||
| 152 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__LOWER_BOUND: | ||
| 153 | return getLowerBound(); | ||
| 154 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__UPPER_BOUND: | ||
| 155 | return getUpperBound(); | ||
| 156 | } | ||
| 157 | return super.eGet(featureID, resolve, coreType); | ||
| 158 | } | ||
| 159 | |||
| 160 | /** | ||
| 161 | * <!-- begin-user-doc --> | ||
| 162 | * <!-- end-user-doc --> | ||
| 163 | * @generated | ||
| 164 | */ | ||
| 165 | @Override | ||
| 166 | public void eSet(int featureID, Object newValue) | ||
| 167 | { | ||
| 168 | switch (featureID) | ||
| 169 | { | ||
| 170 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__LOWER_BOUND: | ||
| 171 | setLowerBound((Integer)newValue); | ||
| 172 | return; | ||
| 173 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__UPPER_BOUND: | ||
| 174 | setUpperBound((Integer)newValue); | ||
| 175 | return; | ||
| 176 | } | ||
| 177 | super.eSet(featureID, newValue); | ||
| 178 | } | ||
| 179 | |||
| 180 | /** | ||
| 181 | * <!-- begin-user-doc --> | ||
| 182 | * <!-- end-user-doc --> | ||
| 183 | * @generated | ||
| 184 | */ | ||
| 185 | @Override | ||
| 186 | public void eUnset(int featureID) | ||
| 187 | { | ||
| 188 | switch (featureID) | ||
| 189 | { | ||
| 190 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__LOWER_BOUND: | ||
| 191 | setLowerBound(LOWER_BOUND_EDEFAULT); | ||
| 192 | return; | ||
| 193 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__UPPER_BOUND: | ||
| 194 | setUpperBound(UPPER_BOUND_EDEFAULT); | ||
| 195 | return; | ||
| 196 | } | ||
| 197 | super.eUnset(featureID); | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public boolean eIsSet(int featureID) | ||
| 207 | { | ||
| 208 | switch (featureID) | ||
| 209 | { | ||
| 210 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__LOWER_BOUND: | ||
| 211 | return lowerBound != LOWER_BOUND_EDEFAULT; | ||
| 212 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY__UPPER_BOUND: | ||
| 213 | return upperBound != UPPER_BOUND_EDEFAULT; | ||
| 214 | } | ||
| 215 | return super.eIsSet(featureID); | ||
| 216 | } | ||
| 217 | |||
| 218 | /** | ||
| 219 | * <!-- begin-user-doc --> | ||
| 220 | * <!-- end-user-doc --> | ||
| 221 | * @generated | ||
| 222 | */ | ||
| 223 | @Override | ||
| 224 | public String toString() | ||
| 225 | { | ||
| 226 | if (eIsProxy()) return super.toString(); | ||
| 227 | |||
| 228 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 229 | result.append(" (lowerBound: "); | ||
| 230 | result.append(lowerBound); | ||
| 231 | result.append(", upperBound: "); | ||
| 232 | result.append(upperBound); | ||
| 233 | result.append(')'); | ||
| 234 | return result.toString(); | ||
| 235 | } | ||
| 236 | |||
| 237 | } //BoundedMultiplicityImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedScopeDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedScopeDefinitionImpl.java new file mode 100644 index 00000000..36bf4f96 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BoundedScopeDefinitionImpl.java | |||
| @@ -0,0 +1,237 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Bounded Scope Definition</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl#getLowerBound <em>Lower Bound</em>}</li> | ||
| 24 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BoundedScopeDefinitionImpl#getUpperBound <em>Upper Bound</em>}</li> | ||
| 25 | * </ul> | ||
| 26 | * | ||
| 27 | * @generated | ||
| 28 | */ | ||
| 29 | public class BoundedScopeDefinitionImpl extends ScopeDefinitionImpl implements BoundedScopeDefinition | ||
| 30 | { | ||
| 31 | /** | ||
| 32 | * The default value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @see #getLowerBound() | ||
| 36 | * @generated | ||
| 37 | * @ordered | ||
| 38 | */ | ||
| 39 | protected static final int LOWER_BOUND_EDEFAULT = 0; | ||
| 40 | |||
| 41 | /** | ||
| 42 | * The cached value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @see #getLowerBound() | ||
| 46 | * @generated | ||
| 47 | * @ordered | ||
| 48 | */ | ||
| 49 | protected int lowerBound = LOWER_BOUND_EDEFAULT; | ||
| 50 | |||
| 51 | /** | ||
| 52 | * The default value of the '{@link #getUpperBound() <em>Upper Bound</em>}' attribute. | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @see #getUpperBound() | ||
| 56 | * @generated | ||
| 57 | * @ordered | ||
| 58 | */ | ||
| 59 | protected static final int UPPER_BOUND_EDEFAULT = 0; | ||
| 60 | |||
| 61 | /** | ||
| 62 | * The cached value of the '{@link #getUpperBound() <em>Upper Bound</em>}' attribute. | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @see #getUpperBound() | ||
| 66 | * @generated | ||
| 67 | * @ordered | ||
| 68 | */ | ||
| 69 | protected int upperBound = UPPER_BOUND_EDEFAULT; | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | protected BoundedScopeDefinitionImpl() | ||
| 77 | { | ||
| 78 | super(); | ||
| 79 | } | ||
| 80 | |||
| 81 | /** | ||
| 82 | * <!-- begin-user-doc --> | ||
| 83 | * <!-- end-user-doc --> | ||
| 84 | * @generated | ||
| 85 | */ | ||
| 86 | @Override | ||
| 87 | protected EClass eStaticClass() | ||
| 88 | { | ||
| 89 | return SolverLanguagePackage.Literals.BOUNDED_SCOPE_DEFINITION; | ||
| 90 | } | ||
| 91 | |||
| 92 | /** | ||
| 93 | * <!-- begin-user-doc --> | ||
| 94 | * <!-- end-user-doc --> | ||
| 95 | * @generated | ||
| 96 | */ | ||
| 97 | @Override | ||
| 98 | public int getLowerBound() | ||
| 99 | { | ||
| 100 | return lowerBound; | ||
| 101 | } | ||
| 102 | |||
| 103 | /** | ||
| 104 | * <!-- begin-user-doc --> | ||
| 105 | * <!-- end-user-doc --> | ||
| 106 | * @generated | ||
| 107 | */ | ||
| 108 | @Override | ||
| 109 | public void setLowerBound(int newLowerBound) | ||
| 110 | { | ||
| 111 | int oldLowerBound = lowerBound; | ||
| 112 | lowerBound = newLowerBound; | ||
| 113 | if (eNotificationRequired()) | ||
| 114 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__LOWER_BOUND, oldLowerBound, lowerBound)); | ||
| 115 | } | ||
| 116 | |||
| 117 | /** | ||
| 118 | * <!-- begin-user-doc --> | ||
| 119 | * <!-- end-user-doc --> | ||
| 120 | * @generated | ||
| 121 | */ | ||
| 122 | @Override | ||
| 123 | public int getUpperBound() | ||
| 124 | { | ||
| 125 | return upperBound; | ||
| 126 | } | ||
| 127 | |||
| 128 | /** | ||
| 129 | * <!-- begin-user-doc --> | ||
| 130 | * <!-- end-user-doc --> | ||
| 131 | * @generated | ||
| 132 | */ | ||
| 133 | @Override | ||
| 134 | public void setUpperBound(int newUpperBound) | ||
| 135 | { | ||
| 136 | int oldUpperBound = upperBound; | ||
| 137 | upperBound = newUpperBound; | ||
| 138 | if (eNotificationRequired()) | ||
| 139 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__UPPER_BOUND, oldUpperBound, upperBound)); | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 149 | { | ||
| 150 | switch (featureID) | ||
| 151 | { | ||
| 152 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 153 | return getLowerBound(); | ||
| 154 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__UPPER_BOUND: | ||
| 155 | return getUpperBound(); | ||
| 156 | } | ||
| 157 | return super.eGet(featureID, resolve, coreType); | ||
| 158 | } | ||
| 159 | |||
| 160 | /** | ||
| 161 | * <!-- begin-user-doc --> | ||
| 162 | * <!-- end-user-doc --> | ||
| 163 | * @generated | ||
| 164 | */ | ||
| 165 | @Override | ||
| 166 | public void eSet(int featureID, Object newValue) | ||
| 167 | { | ||
| 168 | switch (featureID) | ||
| 169 | { | ||
| 170 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 171 | setLowerBound((Integer)newValue); | ||
| 172 | return; | ||
| 173 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__UPPER_BOUND: | ||
| 174 | setUpperBound((Integer)newValue); | ||
| 175 | return; | ||
| 176 | } | ||
| 177 | super.eSet(featureID, newValue); | ||
| 178 | } | ||
| 179 | |||
| 180 | /** | ||
| 181 | * <!-- begin-user-doc --> | ||
| 182 | * <!-- end-user-doc --> | ||
| 183 | * @generated | ||
| 184 | */ | ||
| 185 | @Override | ||
| 186 | public void eUnset(int featureID) | ||
| 187 | { | ||
| 188 | switch (featureID) | ||
| 189 | { | ||
| 190 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 191 | setLowerBound(LOWER_BOUND_EDEFAULT); | ||
| 192 | return; | ||
| 193 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__UPPER_BOUND: | ||
| 194 | setUpperBound(UPPER_BOUND_EDEFAULT); | ||
| 195 | return; | ||
| 196 | } | ||
| 197 | super.eUnset(featureID); | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public boolean eIsSet(int featureID) | ||
| 207 | { | ||
| 208 | switch (featureID) | ||
| 209 | { | ||
| 210 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 211 | return lowerBound != LOWER_BOUND_EDEFAULT; | ||
| 212 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION__UPPER_BOUND: | ||
| 213 | return upperBound != UPPER_BOUND_EDEFAULT; | ||
| 214 | } | ||
| 215 | return super.eIsSet(featureID); | ||
| 216 | } | ||
| 217 | |||
| 218 | /** | ||
| 219 | * <!-- begin-user-doc --> | ||
| 220 | * <!-- end-user-doc --> | ||
| 221 | * @generated | ||
| 222 | */ | ||
| 223 | @Override | ||
| 224 | public String toString() | ||
| 225 | { | ||
| 226 | if (eIsProxy()) return super.toString(); | ||
| 227 | |||
| 228 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 229 | result.append(" (lowerBound: "); | ||
| 230 | result.append(lowerBound); | ||
| 231 | result.append(", upperBound: "); | ||
| 232 | result.append(upperBound); | ||
| 233 | result.append(')'); | ||
| 234 | return result.toString(); | ||
| 235 | } | ||
| 236 | |||
| 237 | } //BoundedScopeDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java deleted file mode 100644 index b23bbba5..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>CD Interpretation</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class CDInterpretationImpl extends InterpretationImpl implements CDInterpretation | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected CDInterpretationImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.CD_INTERPRETATION; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //CDInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CallImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CallImpl.java new file mode 100644 index 00000000..01712ad3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CallImpl.java | |||
| @@ -0,0 +1,401 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Call; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Call</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl#getFunctor <em>Functor</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl#isTransitiveClosure <em>Transitive Closure</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl#isReflexiveTransitiveClosure <em>Reflexive Transitive Closure</em>}</li> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CallImpl#getArgumentList <em>Argument List</em>}</li> | ||
| 31 | * </ul> | ||
| 32 | * | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | public class CallImpl extends ExpressionImpl implements Call | ||
| 36 | { | ||
| 37 | /** | ||
| 38 | * The cached value of the '{@link #getFunctor() <em>Functor</em>}' containment reference. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @see #getFunctor() | ||
| 42 | * @generated | ||
| 43 | * @ordered | ||
| 44 | */ | ||
| 45 | protected Reference functor; | ||
| 46 | |||
| 47 | /** | ||
| 48 | * The default value of the '{@link #isTransitiveClosure() <em>Transitive Closure</em>}' attribute. | ||
| 49 | * <!-- begin-user-doc --> | ||
| 50 | * <!-- end-user-doc --> | ||
| 51 | * @see #isTransitiveClosure() | ||
| 52 | * @generated | ||
| 53 | * @ordered | ||
| 54 | */ | ||
| 55 | protected static final boolean TRANSITIVE_CLOSURE_EDEFAULT = false; | ||
| 56 | |||
| 57 | /** | ||
| 58 | * The cached value of the '{@link #isTransitiveClosure() <em>Transitive Closure</em>}' attribute. | ||
| 59 | * <!-- begin-user-doc --> | ||
| 60 | * <!-- end-user-doc --> | ||
| 61 | * @see #isTransitiveClosure() | ||
| 62 | * @generated | ||
| 63 | * @ordered | ||
| 64 | */ | ||
| 65 | protected boolean transitiveClosure = TRANSITIVE_CLOSURE_EDEFAULT; | ||
| 66 | |||
| 67 | /** | ||
| 68 | * The default value of the '{@link #isReflexiveTransitiveClosure() <em>Reflexive Transitive Closure</em>}' attribute. | ||
| 69 | * <!-- begin-user-doc --> | ||
| 70 | * <!-- end-user-doc --> | ||
| 71 | * @see #isReflexiveTransitiveClosure() | ||
| 72 | * @generated | ||
| 73 | * @ordered | ||
| 74 | */ | ||
| 75 | protected static final boolean REFLEXIVE_TRANSITIVE_CLOSURE_EDEFAULT = false; | ||
| 76 | |||
| 77 | /** | ||
| 78 | * The cached value of the '{@link #isReflexiveTransitiveClosure() <em>Reflexive Transitive Closure</em>}' attribute. | ||
| 79 | * <!-- begin-user-doc --> | ||
| 80 | * <!-- end-user-doc --> | ||
| 81 | * @see #isReflexiveTransitiveClosure() | ||
| 82 | * @generated | ||
| 83 | * @ordered | ||
| 84 | */ | ||
| 85 | protected boolean reflexiveTransitiveClosure = REFLEXIVE_TRANSITIVE_CLOSURE_EDEFAULT; | ||
| 86 | |||
| 87 | /** | ||
| 88 | * The cached value of the '{@link #getArgumentList() <em>Argument List</em>}' containment reference. | ||
| 89 | * <!-- begin-user-doc --> | ||
| 90 | * <!-- end-user-doc --> | ||
| 91 | * @see #getArgumentList() | ||
| 92 | * @generated | ||
| 93 | * @ordered | ||
| 94 | */ | ||
| 95 | protected ArgumentList argumentList; | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | protected CallImpl() | ||
| 103 | { | ||
| 104 | super(); | ||
| 105 | } | ||
| 106 | |||
| 107 | /** | ||
| 108 | * <!-- begin-user-doc --> | ||
| 109 | * <!-- end-user-doc --> | ||
| 110 | * @generated | ||
| 111 | */ | ||
| 112 | @Override | ||
| 113 | protected EClass eStaticClass() | ||
| 114 | { | ||
| 115 | return SolverLanguagePackage.Literals.CALL; | ||
| 116 | } | ||
| 117 | |||
| 118 | /** | ||
| 119 | * <!-- begin-user-doc --> | ||
| 120 | * <!-- end-user-doc --> | ||
| 121 | * @generated | ||
| 122 | */ | ||
| 123 | @Override | ||
| 124 | public Reference getFunctor() | ||
| 125 | { | ||
| 126 | return functor; | ||
| 127 | } | ||
| 128 | |||
| 129 | /** | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @generated | ||
| 133 | */ | ||
| 134 | public NotificationChain basicSetFunctor(Reference newFunctor, NotificationChain msgs) | ||
| 135 | { | ||
| 136 | Reference oldFunctor = functor; | ||
| 137 | functor = newFunctor; | ||
| 138 | if (eNotificationRequired()) | ||
| 139 | { | ||
| 140 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__FUNCTOR, oldFunctor, newFunctor); | ||
| 141 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 142 | } | ||
| 143 | return msgs; | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | @Override | ||
| 152 | public void setFunctor(Reference newFunctor) | ||
| 153 | { | ||
| 154 | if (newFunctor != functor) | ||
| 155 | { | ||
| 156 | NotificationChain msgs = null; | ||
| 157 | if (functor != null) | ||
| 158 | msgs = ((InternalEObject)functor).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CALL__FUNCTOR, null, msgs); | ||
| 159 | if (newFunctor != null) | ||
| 160 | msgs = ((InternalEObject)newFunctor).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CALL__FUNCTOR, null, msgs); | ||
| 161 | msgs = basicSetFunctor(newFunctor, msgs); | ||
| 162 | if (msgs != null) msgs.dispatch(); | ||
| 163 | } | ||
| 164 | else if (eNotificationRequired()) | ||
| 165 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__FUNCTOR, newFunctor, newFunctor)); | ||
| 166 | } | ||
| 167 | |||
| 168 | /** | ||
| 169 | * <!-- begin-user-doc --> | ||
| 170 | * <!-- end-user-doc --> | ||
| 171 | * @generated | ||
| 172 | */ | ||
| 173 | @Override | ||
| 174 | public boolean isTransitiveClosure() | ||
| 175 | { | ||
| 176 | return transitiveClosure; | ||
| 177 | } | ||
| 178 | |||
| 179 | /** | ||
| 180 | * <!-- begin-user-doc --> | ||
| 181 | * <!-- end-user-doc --> | ||
| 182 | * @generated | ||
| 183 | */ | ||
| 184 | @Override | ||
| 185 | public void setTransitiveClosure(boolean newTransitiveClosure) | ||
| 186 | { | ||
| 187 | boolean oldTransitiveClosure = transitiveClosure; | ||
| 188 | transitiveClosure = newTransitiveClosure; | ||
| 189 | if (eNotificationRequired()) | ||
| 190 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__TRANSITIVE_CLOSURE, oldTransitiveClosure, transitiveClosure)); | ||
| 191 | } | ||
| 192 | |||
| 193 | /** | ||
| 194 | * <!-- begin-user-doc --> | ||
| 195 | * <!-- end-user-doc --> | ||
| 196 | * @generated | ||
| 197 | */ | ||
| 198 | @Override | ||
| 199 | public boolean isReflexiveTransitiveClosure() | ||
| 200 | { | ||
| 201 | return reflexiveTransitiveClosure; | ||
| 202 | } | ||
| 203 | |||
| 204 | /** | ||
| 205 | * <!-- begin-user-doc --> | ||
| 206 | * <!-- end-user-doc --> | ||
| 207 | * @generated | ||
| 208 | */ | ||
| 209 | @Override | ||
| 210 | public void setReflexiveTransitiveClosure(boolean newReflexiveTransitiveClosure) | ||
| 211 | { | ||
| 212 | boolean oldReflexiveTransitiveClosure = reflexiveTransitiveClosure; | ||
| 213 | reflexiveTransitiveClosure = newReflexiveTransitiveClosure; | ||
| 214 | if (eNotificationRequired()) | ||
| 215 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__REFLEXIVE_TRANSITIVE_CLOSURE, oldReflexiveTransitiveClosure, reflexiveTransitiveClosure)); | ||
| 216 | } | ||
| 217 | |||
| 218 | /** | ||
| 219 | * <!-- begin-user-doc --> | ||
| 220 | * <!-- end-user-doc --> | ||
| 221 | * @generated | ||
| 222 | */ | ||
| 223 | @Override | ||
| 224 | public ArgumentList getArgumentList() | ||
| 225 | { | ||
| 226 | return argumentList; | ||
| 227 | } | ||
| 228 | |||
| 229 | /** | ||
| 230 | * <!-- begin-user-doc --> | ||
| 231 | * <!-- end-user-doc --> | ||
| 232 | * @generated | ||
| 233 | */ | ||
| 234 | public NotificationChain basicSetArgumentList(ArgumentList newArgumentList, NotificationChain msgs) | ||
| 235 | { | ||
| 236 | ArgumentList oldArgumentList = argumentList; | ||
| 237 | argumentList = newArgumentList; | ||
| 238 | if (eNotificationRequired()) | ||
| 239 | { | ||
| 240 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__ARGUMENT_LIST, oldArgumentList, newArgumentList); | ||
| 241 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 242 | } | ||
| 243 | return msgs; | ||
| 244 | } | ||
| 245 | |||
| 246 | /** | ||
| 247 | * <!-- begin-user-doc --> | ||
| 248 | * <!-- end-user-doc --> | ||
| 249 | * @generated | ||
| 250 | */ | ||
| 251 | @Override | ||
| 252 | public void setArgumentList(ArgumentList newArgumentList) | ||
| 253 | { | ||
| 254 | if (newArgumentList != argumentList) | ||
| 255 | { | ||
| 256 | NotificationChain msgs = null; | ||
| 257 | if (argumentList != null) | ||
| 258 | msgs = ((InternalEObject)argumentList).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CALL__ARGUMENT_LIST, null, msgs); | ||
| 259 | if (newArgumentList != null) | ||
| 260 | msgs = ((InternalEObject)newArgumentList).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CALL__ARGUMENT_LIST, null, msgs); | ||
| 261 | msgs = basicSetArgumentList(newArgumentList, msgs); | ||
| 262 | if (msgs != null) msgs.dispatch(); | ||
| 263 | } | ||
| 264 | else if (eNotificationRequired()) | ||
| 265 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CALL__ARGUMENT_LIST, newArgumentList, newArgumentList)); | ||
| 266 | } | ||
| 267 | |||
| 268 | /** | ||
| 269 | * <!-- begin-user-doc --> | ||
| 270 | * <!-- end-user-doc --> | ||
| 271 | * @generated | ||
| 272 | */ | ||
| 273 | @Override | ||
| 274 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 275 | { | ||
| 276 | switch (featureID) | ||
| 277 | { | ||
| 278 | case SolverLanguagePackage.CALL__FUNCTOR: | ||
| 279 | return basicSetFunctor(null, msgs); | ||
| 280 | case SolverLanguagePackage.CALL__ARGUMENT_LIST: | ||
| 281 | return basicSetArgumentList(null, msgs); | ||
| 282 | } | ||
| 283 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 284 | } | ||
| 285 | |||
| 286 | /** | ||
| 287 | * <!-- begin-user-doc --> | ||
| 288 | * <!-- end-user-doc --> | ||
| 289 | * @generated | ||
| 290 | */ | ||
| 291 | @Override | ||
| 292 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 293 | { | ||
| 294 | switch (featureID) | ||
| 295 | { | ||
| 296 | case SolverLanguagePackage.CALL__FUNCTOR: | ||
| 297 | return getFunctor(); | ||
| 298 | case SolverLanguagePackage.CALL__TRANSITIVE_CLOSURE: | ||
| 299 | return isTransitiveClosure(); | ||
| 300 | case SolverLanguagePackage.CALL__REFLEXIVE_TRANSITIVE_CLOSURE: | ||
| 301 | return isReflexiveTransitiveClosure(); | ||
| 302 | case SolverLanguagePackage.CALL__ARGUMENT_LIST: | ||
| 303 | return getArgumentList(); | ||
| 304 | } | ||
| 305 | return super.eGet(featureID, resolve, coreType); | ||
| 306 | } | ||
| 307 | |||
| 308 | /** | ||
| 309 | * <!-- begin-user-doc --> | ||
| 310 | * <!-- end-user-doc --> | ||
| 311 | * @generated | ||
| 312 | */ | ||
| 313 | @Override | ||
| 314 | public void eSet(int featureID, Object newValue) | ||
| 315 | { | ||
| 316 | switch (featureID) | ||
| 317 | { | ||
| 318 | case SolverLanguagePackage.CALL__FUNCTOR: | ||
| 319 | setFunctor((Reference)newValue); | ||
| 320 | return; | ||
| 321 | case SolverLanguagePackage.CALL__TRANSITIVE_CLOSURE: | ||
| 322 | setTransitiveClosure((Boolean)newValue); | ||
| 323 | return; | ||
| 324 | case SolverLanguagePackage.CALL__REFLEXIVE_TRANSITIVE_CLOSURE: | ||
| 325 | setReflexiveTransitiveClosure((Boolean)newValue); | ||
| 326 | return; | ||
| 327 | case SolverLanguagePackage.CALL__ARGUMENT_LIST: | ||
| 328 | setArgumentList((ArgumentList)newValue); | ||
| 329 | return; | ||
| 330 | } | ||
| 331 | super.eSet(featureID, newValue); | ||
| 332 | } | ||
| 333 | |||
| 334 | /** | ||
| 335 | * <!-- begin-user-doc --> | ||
| 336 | * <!-- end-user-doc --> | ||
| 337 | * @generated | ||
| 338 | */ | ||
| 339 | @Override | ||
| 340 | public void eUnset(int featureID) | ||
| 341 | { | ||
| 342 | switch (featureID) | ||
| 343 | { | ||
| 344 | case SolverLanguagePackage.CALL__FUNCTOR: | ||
| 345 | setFunctor((Reference)null); | ||
| 346 | return; | ||
| 347 | case SolverLanguagePackage.CALL__TRANSITIVE_CLOSURE: | ||
| 348 | setTransitiveClosure(TRANSITIVE_CLOSURE_EDEFAULT); | ||
| 349 | return; | ||
| 350 | case SolverLanguagePackage.CALL__REFLEXIVE_TRANSITIVE_CLOSURE: | ||
| 351 | setReflexiveTransitiveClosure(REFLEXIVE_TRANSITIVE_CLOSURE_EDEFAULT); | ||
| 352 | return; | ||
| 353 | case SolverLanguagePackage.CALL__ARGUMENT_LIST: | ||
| 354 | setArgumentList((ArgumentList)null); | ||
| 355 | return; | ||
| 356 | } | ||
| 357 | super.eUnset(featureID); | ||
| 358 | } | ||
| 359 | |||
| 360 | /** | ||
| 361 | * <!-- begin-user-doc --> | ||
| 362 | * <!-- end-user-doc --> | ||
| 363 | * @generated | ||
| 364 | */ | ||
| 365 | @Override | ||
| 366 | public boolean eIsSet(int featureID) | ||
| 367 | { | ||
| 368 | switch (featureID) | ||
| 369 | { | ||
| 370 | case SolverLanguagePackage.CALL__FUNCTOR: | ||
| 371 | return functor != null; | ||
| 372 | case SolverLanguagePackage.CALL__TRANSITIVE_CLOSURE: | ||
| 373 | return transitiveClosure != TRANSITIVE_CLOSURE_EDEFAULT; | ||
| 374 | case SolverLanguagePackage.CALL__REFLEXIVE_TRANSITIVE_CLOSURE: | ||
| 375 | return reflexiveTransitiveClosure != REFLEXIVE_TRANSITIVE_CLOSURE_EDEFAULT; | ||
| 376 | case SolverLanguagePackage.CALL__ARGUMENT_LIST: | ||
| 377 | return argumentList != null; | ||
| 378 | } | ||
| 379 | return super.eIsSet(featureID); | ||
| 380 | } | ||
| 381 | |||
| 382 | /** | ||
| 383 | * <!-- begin-user-doc --> | ||
| 384 | * <!-- end-user-doc --> | ||
| 385 | * @generated | ||
| 386 | */ | ||
| 387 | @Override | ||
| 388 | public String toString() | ||
| 389 | { | ||
| 390 | if (eIsProxy()) return super.toString(); | ||
| 391 | |||
| 392 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 393 | result.append(" (transitiveClosure: "); | ||
| 394 | result.append(transitiveClosure); | ||
| 395 | result.append(", reflexiveTransitiveClosure: "); | ||
| 396 | result.append(reflexiveTransitiveClosure); | ||
| 397 | result.append(')'); | ||
| 398 | return result.toString(); | ||
| 399 | } | ||
| 400 | |||
| 401 | } //CallImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CaseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CaseImpl.java new file mode 100644 index 00000000..47245831 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CaseImpl.java | |||
| @@ -0,0 +1,269 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Case; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 17 | |||
| 18 | /** | ||
| 19 | * <!-- begin-user-doc --> | ||
| 20 | * An implementation of the model object '<em><b>Case</b></em>'. | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * <p> | ||
| 23 | * The following features are implemented: | ||
| 24 | * </p> | ||
| 25 | * <ul> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl#getCondition <em>Condition</em>}</li> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CaseImpl#getBody <em>Body</em>}</li> | ||
| 28 | * </ul> | ||
| 29 | * | ||
| 30 | * @generated | ||
| 31 | */ | ||
| 32 | public class CaseImpl extends ExpressionImpl implements Case | ||
| 33 | { | ||
| 34 | /** | ||
| 35 | * The cached value of the '{@link #getCondition() <em>Condition</em>}' containment reference. | ||
| 36 | * <!-- begin-user-doc --> | ||
| 37 | * <!-- end-user-doc --> | ||
| 38 | * @see #getCondition() | ||
| 39 | * @generated | ||
| 40 | * @ordered | ||
| 41 | */ | ||
| 42 | protected Expression condition; | ||
| 43 | |||
| 44 | /** | ||
| 45 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 46 | * <!-- begin-user-doc --> | ||
| 47 | * <!-- end-user-doc --> | ||
| 48 | * @see #getBody() | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | protected Expression body; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | protected CaseImpl() | ||
| 60 | { | ||
| 61 | super(); | ||
| 62 | } | ||
| 63 | |||
| 64 | /** | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @generated | ||
| 68 | */ | ||
| 69 | @Override | ||
| 70 | protected EClass eStaticClass() | ||
| 71 | { | ||
| 72 | return SolverLanguagePackage.Literals.CASE; | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | public Expression getCondition() | ||
| 82 | { | ||
| 83 | return condition; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs) | ||
| 92 | { | ||
| 93 | Expression oldCondition = condition; | ||
| 94 | condition = newCondition; | ||
| 95 | if (eNotificationRequired()) | ||
| 96 | { | ||
| 97 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CASE__CONDITION, oldCondition, newCondition); | ||
| 98 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 99 | } | ||
| 100 | return msgs; | ||
| 101 | } | ||
| 102 | |||
| 103 | /** | ||
| 104 | * <!-- begin-user-doc --> | ||
| 105 | * <!-- end-user-doc --> | ||
| 106 | * @generated | ||
| 107 | */ | ||
| 108 | @Override | ||
| 109 | public void setCondition(Expression newCondition) | ||
| 110 | { | ||
| 111 | if (newCondition != condition) | ||
| 112 | { | ||
| 113 | NotificationChain msgs = null; | ||
| 114 | if (condition != null) | ||
| 115 | msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CASE__CONDITION, null, msgs); | ||
| 116 | if (newCondition != null) | ||
| 117 | msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CASE__CONDITION, null, msgs); | ||
| 118 | msgs = basicSetCondition(newCondition, msgs); | ||
| 119 | if (msgs != null) msgs.dispatch(); | ||
| 120 | } | ||
| 121 | else if (eNotificationRequired()) | ||
| 122 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CASE__CONDITION, newCondition, newCondition)); | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public Expression getBody() | ||
| 132 | { | ||
| 133 | return body; | ||
| 134 | } | ||
| 135 | |||
| 136 | /** | ||
| 137 | * <!-- begin-user-doc --> | ||
| 138 | * <!-- end-user-doc --> | ||
| 139 | * @generated | ||
| 140 | */ | ||
| 141 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 142 | { | ||
| 143 | Expression oldBody = body; | ||
| 144 | body = newBody; | ||
| 145 | if (eNotificationRequired()) | ||
| 146 | { | ||
| 147 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CASE__BODY, oldBody, newBody); | ||
| 148 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 149 | } | ||
| 150 | return msgs; | ||
| 151 | } | ||
| 152 | |||
| 153 | /** | ||
| 154 | * <!-- begin-user-doc --> | ||
| 155 | * <!-- end-user-doc --> | ||
| 156 | * @generated | ||
| 157 | */ | ||
| 158 | @Override | ||
| 159 | public void setBody(Expression newBody) | ||
| 160 | { | ||
| 161 | if (newBody != body) | ||
| 162 | { | ||
| 163 | NotificationChain msgs = null; | ||
| 164 | if (body != null) | ||
| 165 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CASE__BODY, null, msgs); | ||
| 166 | if (newBody != null) | ||
| 167 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CASE__BODY, null, msgs); | ||
| 168 | msgs = basicSetBody(newBody, msgs); | ||
| 169 | if (msgs != null) msgs.dispatch(); | ||
| 170 | } | ||
| 171 | else if (eNotificationRequired()) | ||
| 172 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CASE__BODY, newBody, newBody)); | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | @Override | ||
| 181 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 182 | { | ||
| 183 | switch (featureID) | ||
| 184 | { | ||
| 185 | case SolverLanguagePackage.CASE__CONDITION: | ||
| 186 | return basicSetCondition(null, msgs); | ||
| 187 | case SolverLanguagePackage.CASE__BODY: | ||
| 188 | return basicSetBody(null, msgs); | ||
| 189 | } | ||
| 190 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 191 | } | ||
| 192 | |||
| 193 | /** | ||
| 194 | * <!-- begin-user-doc --> | ||
| 195 | * <!-- end-user-doc --> | ||
| 196 | * @generated | ||
| 197 | */ | ||
| 198 | @Override | ||
| 199 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 200 | { | ||
| 201 | switch (featureID) | ||
| 202 | { | ||
| 203 | case SolverLanguagePackage.CASE__CONDITION: | ||
| 204 | return getCondition(); | ||
| 205 | case SolverLanguagePackage.CASE__BODY: | ||
| 206 | return getBody(); | ||
| 207 | } | ||
| 208 | return super.eGet(featureID, resolve, coreType); | ||
| 209 | } | ||
| 210 | |||
| 211 | /** | ||
| 212 | * <!-- begin-user-doc --> | ||
| 213 | * <!-- end-user-doc --> | ||
| 214 | * @generated | ||
| 215 | */ | ||
| 216 | @Override | ||
| 217 | public void eSet(int featureID, Object newValue) | ||
| 218 | { | ||
| 219 | switch (featureID) | ||
| 220 | { | ||
| 221 | case SolverLanguagePackage.CASE__CONDITION: | ||
| 222 | setCondition((Expression)newValue); | ||
| 223 | return; | ||
| 224 | case SolverLanguagePackage.CASE__BODY: | ||
| 225 | setBody((Expression)newValue); | ||
| 226 | return; | ||
| 227 | } | ||
| 228 | super.eSet(featureID, newValue); | ||
| 229 | } | ||
| 230 | |||
| 231 | /** | ||
| 232 | * <!-- begin-user-doc --> | ||
| 233 | * <!-- end-user-doc --> | ||
| 234 | * @generated | ||
| 235 | */ | ||
| 236 | @Override | ||
| 237 | public void eUnset(int featureID) | ||
| 238 | { | ||
| 239 | switch (featureID) | ||
| 240 | { | ||
| 241 | case SolverLanguagePackage.CASE__CONDITION: | ||
| 242 | setCondition((Expression)null); | ||
| 243 | return; | ||
| 244 | case SolverLanguagePackage.CASE__BODY: | ||
| 245 | setBody((Expression)null); | ||
| 246 | return; | ||
| 247 | } | ||
| 248 | super.eUnset(featureID); | ||
| 249 | } | ||
| 250 | |||
| 251 | /** | ||
| 252 | * <!-- begin-user-doc --> | ||
| 253 | * <!-- end-user-doc --> | ||
| 254 | * @generated | ||
| 255 | */ | ||
| 256 | @Override | ||
| 257 | public boolean eIsSet(int featureID) | ||
| 258 | { | ||
| 259 | switch (featureID) | ||
| 260 | { | ||
| 261 | case SolverLanguagePackage.CASE__CONDITION: | ||
| 262 | return condition != null; | ||
| 263 | case SolverLanguagePackage.CASE__BODY: | ||
| 264 | return body != null; | ||
| 265 | } | ||
| 266 | return super.eIsSet(featureID); | ||
| 267 | } | ||
| 268 | |||
| 269 | } //CaseImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassDefinitionImpl.java new file mode 100644 index 00000000..f0a81764 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassDefinitionImpl.java | |||
| @@ -0,0 +1,340 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | |||
| 18 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 19 | import org.eclipse.emf.ecore.util.EObjectResolvingEList; | ||
| 20 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 21 | |||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 26 | |||
| 27 | /** | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * An implementation of the model object '<em><b>Class Definition</b></em>'. | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * <p> | ||
| 32 | * The following features are implemented: | ||
| 33 | * </p> | ||
| 34 | * <ul> | ||
| 35 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl#isAbstract <em>Abstract</em>}</li> | ||
| 36 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl#getName <em>Name</em>}</li> | ||
| 37 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl#getSuperclasses <em>Superclasses</em>}</li> | ||
| 38 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassDefinitionImpl#getMembers <em>Members</em>}</li> | ||
| 39 | * </ul> | ||
| 40 | * | ||
| 41 | * @generated | ||
| 42 | */ | ||
| 43 | public class ClassDefinitionImpl extends StatementImpl implements ClassDefinition | ||
| 44 | { | ||
| 45 | /** | ||
| 46 | * The default value of the '{@link #isAbstract() <em>Abstract</em>}' attribute. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #isAbstract() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected static final boolean ABSTRACT_EDEFAULT = false; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #isAbstract() <em>Abstract</em>}' attribute. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #isAbstract() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected boolean abstract_ = ABSTRACT_EDEFAULT; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 67 | * <!-- begin-user-doc --> | ||
| 68 | * <!-- end-user-doc --> | ||
| 69 | * @see #getName() | ||
| 70 | * @generated | ||
| 71 | * @ordered | ||
| 72 | */ | ||
| 73 | protected static final String NAME_EDEFAULT = null; | ||
| 74 | |||
| 75 | /** | ||
| 76 | * The cached value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @see #getName() | ||
| 80 | * @generated | ||
| 81 | * @ordered | ||
| 82 | */ | ||
| 83 | protected String name = NAME_EDEFAULT; | ||
| 84 | |||
| 85 | /** | ||
| 86 | * The cached value of the '{@link #getSuperclasses() <em>Superclasses</em>}' reference list. | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @see #getSuperclasses() | ||
| 90 | * @generated | ||
| 91 | * @ordered | ||
| 92 | */ | ||
| 93 | protected EList<NamedElement> superclasses; | ||
| 94 | |||
| 95 | /** | ||
| 96 | * The cached value of the '{@link #getMembers() <em>Members</em>}' containment reference list. | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @see #getMembers() | ||
| 100 | * @generated | ||
| 101 | * @ordered | ||
| 102 | */ | ||
| 103 | protected EList<MemberDefinition> members; | ||
| 104 | |||
| 105 | /** | ||
| 106 | * <!-- begin-user-doc --> | ||
| 107 | * <!-- end-user-doc --> | ||
| 108 | * @generated | ||
| 109 | */ | ||
| 110 | protected ClassDefinitionImpl() | ||
| 111 | { | ||
| 112 | super(); | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * <!-- begin-user-doc --> | ||
| 117 | * <!-- end-user-doc --> | ||
| 118 | * @generated | ||
| 119 | */ | ||
| 120 | @Override | ||
| 121 | protected EClass eStaticClass() | ||
| 122 | { | ||
| 123 | return SolverLanguagePackage.Literals.CLASS_DEFINITION; | ||
| 124 | } | ||
| 125 | |||
| 126 | /** | ||
| 127 | * <!-- begin-user-doc --> | ||
| 128 | * <!-- end-user-doc --> | ||
| 129 | * @generated | ||
| 130 | */ | ||
| 131 | @Override | ||
| 132 | public boolean isAbstract() | ||
| 133 | { | ||
| 134 | return abstract_; | ||
| 135 | } | ||
| 136 | |||
| 137 | /** | ||
| 138 | * <!-- begin-user-doc --> | ||
| 139 | * <!-- end-user-doc --> | ||
| 140 | * @generated | ||
| 141 | */ | ||
| 142 | @Override | ||
| 143 | public void setAbstract(boolean newAbstract) | ||
| 144 | { | ||
| 145 | boolean oldAbstract = abstract_; | ||
| 146 | abstract_ = newAbstract; | ||
| 147 | if (eNotificationRequired()) | ||
| 148 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_DEFINITION__ABSTRACT, oldAbstract, abstract_)); | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * <!-- begin-user-doc --> | ||
| 153 | * <!-- end-user-doc --> | ||
| 154 | * @generated | ||
| 155 | */ | ||
| 156 | @Override | ||
| 157 | public String getName() | ||
| 158 | { | ||
| 159 | return name; | ||
| 160 | } | ||
| 161 | |||
| 162 | /** | ||
| 163 | * <!-- begin-user-doc --> | ||
| 164 | * <!-- end-user-doc --> | ||
| 165 | * @generated | ||
| 166 | */ | ||
| 167 | @Override | ||
| 168 | public void setName(String newName) | ||
| 169 | { | ||
| 170 | String oldName = name; | ||
| 171 | name = newName; | ||
| 172 | if (eNotificationRequired()) | ||
| 173 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_DEFINITION__NAME, oldName, name)); | ||
| 174 | } | ||
| 175 | |||
| 176 | /** | ||
| 177 | * <!-- begin-user-doc --> | ||
| 178 | * <!-- end-user-doc --> | ||
| 179 | * @generated | ||
| 180 | */ | ||
| 181 | @Override | ||
| 182 | public EList<NamedElement> getSuperclasses() | ||
| 183 | { | ||
| 184 | if (superclasses == null) | ||
| 185 | { | ||
| 186 | superclasses = new EObjectResolvingEList<NamedElement>(NamedElement.class, this, SolverLanguagePackage.CLASS_DEFINITION__SUPERCLASSES); | ||
| 187 | } | ||
| 188 | return superclasses; | ||
| 189 | } | ||
| 190 | |||
| 191 | /** | ||
| 192 | * <!-- begin-user-doc --> | ||
| 193 | * <!-- end-user-doc --> | ||
| 194 | * @generated | ||
| 195 | */ | ||
| 196 | @Override | ||
| 197 | public EList<MemberDefinition> getMembers() | ||
| 198 | { | ||
| 199 | if (members == null) | ||
| 200 | { | ||
| 201 | members = new EObjectContainmentEList<MemberDefinition>(MemberDefinition.class, this, SolverLanguagePackage.CLASS_DEFINITION__MEMBERS); | ||
| 202 | } | ||
| 203 | return members; | ||
| 204 | } | ||
| 205 | |||
| 206 | /** | ||
| 207 | * <!-- begin-user-doc --> | ||
| 208 | * <!-- end-user-doc --> | ||
| 209 | * @generated | ||
| 210 | */ | ||
| 211 | @Override | ||
| 212 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 213 | { | ||
| 214 | switch (featureID) | ||
| 215 | { | ||
| 216 | case SolverLanguagePackage.CLASS_DEFINITION__MEMBERS: | ||
| 217 | return ((InternalEList<?>)getMembers()).basicRemove(otherEnd, msgs); | ||
| 218 | } | ||
| 219 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 220 | } | ||
| 221 | |||
| 222 | /** | ||
| 223 | * <!-- begin-user-doc --> | ||
| 224 | * <!-- end-user-doc --> | ||
| 225 | * @generated | ||
| 226 | */ | ||
| 227 | @Override | ||
| 228 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 229 | { | ||
| 230 | switch (featureID) | ||
| 231 | { | ||
| 232 | case SolverLanguagePackage.CLASS_DEFINITION__ABSTRACT: | ||
| 233 | return isAbstract(); | ||
| 234 | case SolverLanguagePackage.CLASS_DEFINITION__NAME: | ||
| 235 | return getName(); | ||
| 236 | case SolverLanguagePackage.CLASS_DEFINITION__SUPERCLASSES: | ||
| 237 | return getSuperclasses(); | ||
| 238 | case SolverLanguagePackage.CLASS_DEFINITION__MEMBERS: | ||
| 239 | return getMembers(); | ||
| 240 | } | ||
| 241 | return super.eGet(featureID, resolve, coreType); | ||
| 242 | } | ||
| 243 | |||
| 244 | /** | ||
| 245 | * <!-- begin-user-doc --> | ||
| 246 | * <!-- end-user-doc --> | ||
| 247 | * @generated | ||
| 248 | */ | ||
| 249 | @SuppressWarnings("unchecked") | ||
| 250 | @Override | ||
| 251 | public void eSet(int featureID, Object newValue) | ||
| 252 | { | ||
| 253 | switch (featureID) | ||
| 254 | { | ||
| 255 | case SolverLanguagePackage.CLASS_DEFINITION__ABSTRACT: | ||
| 256 | setAbstract((Boolean)newValue); | ||
| 257 | return; | ||
| 258 | case SolverLanguagePackage.CLASS_DEFINITION__NAME: | ||
| 259 | setName((String)newValue); | ||
| 260 | return; | ||
| 261 | case SolverLanguagePackage.CLASS_DEFINITION__SUPERCLASSES: | ||
| 262 | getSuperclasses().clear(); | ||
| 263 | getSuperclasses().addAll((Collection<? extends NamedElement>)newValue); | ||
| 264 | return; | ||
| 265 | case SolverLanguagePackage.CLASS_DEFINITION__MEMBERS: | ||
| 266 | getMembers().clear(); | ||
| 267 | getMembers().addAll((Collection<? extends MemberDefinition>)newValue); | ||
| 268 | return; | ||
| 269 | } | ||
| 270 | super.eSet(featureID, newValue); | ||
| 271 | } | ||
| 272 | |||
| 273 | /** | ||
| 274 | * <!-- begin-user-doc --> | ||
| 275 | * <!-- end-user-doc --> | ||
| 276 | * @generated | ||
| 277 | */ | ||
| 278 | @Override | ||
| 279 | public void eUnset(int featureID) | ||
| 280 | { | ||
| 281 | switch (featureID) | ||
| 282 | { | ||
| 283 | case SolverLanguagePackage.CLASS_DEFINITION__ABSTRACT: | ||
| 284 | setAbstract(ABSTRACT_EDEFAULT); | ||
| 285 | return; | ||
| 286 | case SolverLanguagePackage.CLASS_DEFINITION__NAME: | ||
| 287 | setName(NAME_EDEFAULT); | ||
| 288 | return; | ||
| 289 | case SolverLanguagePackage.CLASS_DEFINITION__SUPERCLASSES: | ||
| 290 | getSuperclasses().clear(); | ||
| 291 | return; | ||
| 292 | case SolverLanguagePackage.CLASS_DEFINITION__MEMBERS: | ||
| 293 | getMembers().clear(); | ||
| 294 | return; | ||
| 295 | } | ||
| 296 | super.eUnset(featureID); | ||
| 297 | } | ||
| 298 | |||
| 299 | /** | ||
| 300 | * <!-- begin-user-doc --> | ||
| 301 | * <!-- end-user-doc --> | ||
| 302 | * @generated | ||
| 303 | */ | ||
| 304 | @Override | ||
| 305 | public boolean eIsSet(int featureID) | ||
| 306 | { | ||
| 307 | switch (featureID) | ||
| 308 | { | ||
| 309 | case SolverLanguagePackage.CLASS_DEFINITION__ABSTRACT: | ||
| 310 | return abstract_ != ABSTRACT_EDEFAULT; | ||
| 311 | case SolverLanguagePackage.CLASS_DEFINITION__NAME: | ||
| 312 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | ||
| 313 | case SolverLanguagePackage.CLASS_DEFINITION__SUPERCLASSES: | ||
| 314 | return superclasses != null && !superclasses.isEmpty(); | ||
| 315 | case SolverLanguagePackage.CLASS_DEFINITION__MEMBERS: | ||
| 316 | return members != null && !members.isEmpty(); | ||
| 317 | } | ||
| 318 | return super.eIsSet(featureID); | ||
| 319 | } | ||
| 320 | |||
| 321 | /** | ||
| 322 | * <!-- begin-user-doc --> | ||
| 323 | * <!-- end-user-doc --> | ||
| 324 | * @generated | ||
| 325 | */ | ||
| 326 | @Override | ||
| 327 | public String toString() | ||
| 328 | { | ||
| 329 | if (eIsProxy()) return super.toString(); | ||
| 330 | |||
| 331 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 332 | result.append(" (abstract: "); | ||
| 333 | result.append(abstract_); | ||
| 334 | result.append(", name: "); | ||
| 335 | result.append(name); | ||
| 336 | result.append(')'); | ||
| 337 | return result.toString(); | ||
| 338 | } | ||
| 339 | |||
| 340 | } //ClassDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java deleted file mode 100644 index effc5970..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java +++ /dev/null | |||
| @@ -1,356 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | |||
| 18 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 19 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 20 | |||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 25 | |||
| 26 | /** | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * An implementation of the model object '<em><b>Class Interpretation</b></em>'. | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * <p> | ||
| 31 | * The following features are implemented: | ||
| 32 | * </p> | ||
| 33 | * <ul> | ||
| 34 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#isAbstract <em>Abstract</em>}</li> | ||
| 35 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSymbol <em>Symbol</em>}</li> | ||
| 36 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSupertypes <em>Supertypes</em>}</li> | ||
| 37 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getFielt <em>Fielt</em>}</li> | ||
| 38 | * </ul> | ||
| 39 | * | ||
| 40 | * @generated | ||
| 41 | */ | ||
| 42 | public class ClassInterpretationImpl extends CDInterpretationImpl implements ClassInterpretation | ||
| 43 | { | ||
| 44 | /** | ||
| 45 | * The default value of the '{@link #isAbstract() <em>Abstract</em>}' attribute. | ||
| 46 | * <!-- begin-user-doc --> | ||
| 47 | * <!-- end-user-doc --> | ||
| 48 | * @see #isAbstract() | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | protected static final boolean ABSTRACT_EDEFAULT = false; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * The cached value of the '{@link #isAbstract() <em>Abstract</em>}' attribute. | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @see #isAbstract() | ||
| 59 | * @generated | ||
| 60 | * @ordered | ||
| 61 | */ | ||
| 62 | protected boolean abstract_ = ABSTRACT_EDEFAULT; | ||
| 63 | |||
| 64 | /** | ||
| 65 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @see #getSymbol() | ||
| 69 | * @generated | ||
| 70 | * @ordered | ||
| 71 | */ | ||
| 72 | protected ModelSymbol symbol; | ||
| 73 | |||
| 74 | /** | ||
| 75 | * The cached value of the '{@link #getSupertypes() <em>Supertypes</em>}' containment reference list. | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @see #getSupertypes() | ||
| 79 | * @generated | ||
| 80 | * @ordered | ||
| 81 | */ | ||
| 82 | protected EList<ModelSymbol> supertypes; | ||
| 83 | |||
| 84 | /** | ||
| 85 | * The cached value of the '{@link #getFielt() <em>Fielt</em>}' containment reference list. | ||
| 86 | * <!-- begin-user-doc --> | ||
| 87 | * <!-- end-user-doc --> | ||
| 88 | * @see #getFielt() | ||
| 89 | * @generated | ||
| 90 | * @ordered | ||
| 91 | */ | ||
| 92 | protected EList<FieldRelationInterpretation> fielt; | ||
| 93 | |||
| 94 | /** | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @generated | ||
| 98 | */ | ||
| 99 | protected ClassInterpretationImpl() | ||
| 100 | { | ||
| 101 | super(); | ||
| 102 | } | ||
| 103 | |||
| 104 | /** | ||
| 105 | * <!-- begin-user-doc --> | ||
| 106 | * <!-- end-user-doc --> | ||
| 107 | * @generated | ||
| 108 | */ | ||
| 109 | @Override | ||
| 110 | protected EClass eStaticClass() | ||
| 111 | { | ||
| 112 | return SolverLanguagePackage.Literals.CLASS_INTERPRETATION; | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * <!-- begin-user-doc --> | ||
| 117 | * <!-- end-user-doc --> | ||
| 118 | * @generated | ||
| 119 | */ | ||
| 120 | @Override | ||
| 121 | public boolean isAbstract() | ||
| 122 | { | ||
| 123 | return abstract_; | ||
| 124 | } | ||
| 125 | |||
| 126 | /** | ||
| 127 | * <!-- begin-user-doc --> | ||
| 128 | * <!-- end-user-doc --> | ||
| 129 | * @generated | ||
| 130 | */ | ||
| 131 | @Override | ||
| 132 | public void setAbstract(boolean newAbstract) | ||
| 133 | { | ||
| 134 | boolean oldAbstract = abstract_; | ||
| 135 | abstract_ = newAbstract; | ||
| 136 | if (eNotificationRequired()) | ||
| 137 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT, oldAbstract, abstract_)); | ||
| 138 | } | ||
| 139 | |||
| 140 | /** | ||
| 141 | * <!-- begin-user-doc --> | ||
| 142 | * <!-- end-user-doc --> | ||
| 143 | * @generated | ||
| 144 | */ | ||
| 145 | @Override | ||
| 146 | public ModelSymbol getSymbol() | ||
| 147 | { | ||
| 148 | return symbol; | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * <!-- begin-user-doc --> | ||
| 153 | * <!-- end-user-doc --> | ||
| 154 | * @generated | ||
| 155 | */ | ||
| 156 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 157 | { | ||
| 158 | ModelSymbol oldSymbol = symbol; | ||
| 159 | symbol = newSymbol; | ||
| 160 | if (eNotificationRequired()) | ||
| 161 | { | ||
| 162 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); | ||
| 163 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 164 | } | ||
| 165 | return msgs; | ||
| 166 | } | ||
| 167 | |||
| 168 | /** | ||
| 169 | * <!-- begin-user-doc --> | ||
| 170 | * <!-- end-user-doc --> | ||
| 171 | * @generated | ||
| 172 | */ | ||
| 173 | @Override | ||
| 174 | public void setSymbol(ModelSymbol newSymbol) | ||
| 175 | { | ||
| 176 | if (newSymbol != symbol) | ||
| 177 | { | ||
| 178 | NotificationChain msgs = null; | ||
| 179 | if (symbol != null) | ||
| 180 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs); | ||
| 181 | if (newSymbol != null) | ||
| 182 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs); | ||
| 183 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 184 | if (msgs != null) msgs.dispatch(); | ||
| 185 | } | ||
| 186 | else if (eNotificationRequired()) | ||
| 187 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); | ||
| 188 | } | ||
| 189 | |||
| 190 | /** | ||
| 191 | * <!-- begin-user-doc --> | ||
| 192 | * <!-- end-user-doc --> | ||
| 193 | * @generated | ||
| 194 | */ | ||
| 195 | @Override | ||
| 196 | public EList<ModelSymbol> getSupertypes() | ||
| 197 | { | ||
| 198 | if (supertypes == null) | ||
| 199 | { | ||
| 200 | supertypes = new EObjectContainmentEList<ModelSymbol>(ModelSymbol.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES); | ||
| 201 | } | ||
| 202 | return supertypes; | ||
| 203 | } | ||
| 204 | |||
| 205 | /** | ||
| 206 | * <!-- begin-user-doc --> | ||
| 207 | * <!-- end-user-doc --> | ||
| 208 | * @generated | ||
| 209 | */ | ||
| 210 | @Override | ||
| 211 | public EList<FieldRelationInterpretation> getFielt() | ||
| 212 | { | ||
| 213 | if (fielt == null) | ||
| 214 | { | ||
| 215 | fielt = new EObjectContainmentEList<FieldRelationInterpretation>(FieldRelationInterpretation.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__FIELT); | ||
| 216 | } | ||
| 217 | return fielt; | ||
| 218 | } | ||
| 219 | |||
| 220 | /** | ||
| 221 | * <!-- begin-user-doc --> | ||
| 222 | * <!-- end-user-doc --> | ||
| 223 | * @generated | ||
| 224 | */ | ||
| 225 | @Override | ||
| 226 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 227 | { | ||
| 228 | switch (featureID) | ||
| 229 | { | ||
| 230 | case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: | ||
| 231 | return basicSetSymbol(null, msgs); | ||
| 232 | case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: | ||
| 233 | return ((InternalEList<?>)getSupertypes()).basicRemove(otherEnd, msgs); | ||
| 234 | case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: | ||
| 235 | return ((InternalEList<?>)getFielt()).basicRemove(otherEnd, msgs); | ||
| 236 | } | ||
| 237 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 238 | } | ||
| 239 | |||
| 240 | /** | ||
| 241 | * <!-- begin-user-doc --> | ||
| 242 | * <!-- end-user-doc --> | ||
| 243 | * @generated | ||
| 244 | */ | ||
| 245 | @Override | ||
| 246 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 247 | { | ||
| 248 | switch (featureID) | ||
| 249 | { | ||
| 250 | case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: | ||
| 251 | return isAbstract(); | ||
| 252 | case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: | ||
| 253 | return getSymbol(); | ||
| 254 | case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: | ||
| 255 | return getSupertypes(); | ||
| 256 | case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: | ||
| 257 | return getFielt(); | ||
| 258 | } | ||
| 259 | return super.eGet(featureID, resolve, coreType); | ||
| 260 | } | ||
| 261 | |||
| 262 | /** | ||
| 263 | * <!-- begin-user-doc --> | ||
| 264 | * <!-- end-user-doc --> | ||
| 265 | * @generated | ||
| 266 | */ | ||
| 267 | @SuppressWarnings("unchecked") | ||
| 268 | @Override | ||
| 269 | public void eSet(int featureID, Object newValue) | ||
| 270 | { | ||
| 271 | switch (featureID) | ||
| 272 | { | ||
| 273 | case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: | ||
| 274 | setAbstract((Boolean)newValue); | ||
| 275 | return; | ||
| 276 | case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: | ||
| 277 | setSymbol((ModelSymbol)newValue); | ||
| 278 | return; | ||
| 279 | case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: | ||
| 280 | getSupertypes().clear(); | ||
| 281 | getSupertypes().addAll((Collection<? extends ModelSymbol>)newValue); | ||
| 282 | return; | ||
| 283 | case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: | ||
| 284 | getFielt().clear(); | ||
| 285 | getFielt().addAll((Collection<? extends FieldRelationInterpretation>)newValue); | ||
| 286 | return; | ||
| 287 | } | ||
| 288 | super.eSet(featureID, newValue); | ||
| 289 | } | ||
| 290 | |||
| 291 | /** | ||
| 292 | * <!-- begin-user-doc --> | ||
| 293 | * <!-- end-user-doc --> | ||
| 294 | * @generated | ||
| 295 | */ | ||
| 296 | @Override | ||
| 297 | public void eUnset(int featureID) | ||
| 298 | { | ||
| 299 | switch (featureID) | ||
| 300 | { | ||
| 301 | case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: | ||
| 302 | setAbstract(ABSTRACT_EDEFAULT); | ||
| 303 | return; | ||
| 304 | case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: | ||
| 305 | setSymbol((ModelSymbol)null); | ||
| 306 | return; | ||
| 307 | case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: | ||
| 308 | getSupertypes().clear(); | ||
| 309 | return; | ||
| 310 | case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: | ||
| 311 | getFielt().clear(); | ||
| 312 | return; | ||
| 313 | } | ||
| 314 | super.eUnset(featureID); | ||
| 315 | } | ||
| 316 | |||
| 317 | /** | ||
| 318 | * <!-- begin-user-doc --> | ||
| 319 | * <!-- end-user-doc --> | ||
| 320 | * @generated | ||
| 321 | */ | ||
| 322 | @Override | ||
| 323 | public boolean eIsSet(int featureID) | ||
| 324 | { | ||
| 325 | switch (featureID) | ||
| 326 | { | ||
| 327 | case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: | ||
| 328 | return abstract_ != ABSTRACT_EDEFAULT; | ||
| 329 | case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: | ||
| 330 | return symbol != null; | ||
| 331 | case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: | ||
| 332 | return supertypes != null && !supertypes.isEmpty(); | ||
| 333 | case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: | ||
| 334 | return fielt != null && !fielt.isEmpty(); | ||
| 335 | } | ||
| 336 | return super.eIsSet(featureID); | ||
| 337 | } | ||
| 338 | |||
| 339 | /** | ||
| 340 | * <!-- begin-user-doc --> | ||
| 341 | * <!-- end-user-doc --> | ||
| 342 | * @generated | ||
| 343 | */ | ||
| 344 | @Override | ||
| 345 | public String toString() | ||
| 346 | { | ||
| 347 | if (eIsProxy()) return super.toString(); | ||
| 348 | |||
| 349 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 350 | result.append(" (abstract: "); | ||
| 351 | result.append(abstract_); | ||
| 352 | result.append(')'); | ||
| 353 | return result.toString(); | ||
| 354 | } | ||
| 355 | |||
| 356 | } //ClassInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComparisonImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComparisonImpl.java new file mode 100644 index 00000000..9e62d7ef --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComparisonImpl.java | |||
| @@ -0,0 +1,343 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Comparison; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Comparison</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl#getLeft <em>Left</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl#getOp <em>Op</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComparisonImpl#getRight <em>Right</em>}</li> | ||
| 30 | * </ul> | ||
| 31 | * | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | public class ComparisonImpl extends ExpressionImpl implements Comparison | ||
| 35 | { | ||
| 36 | /** | ||
| 37 | * The cached value of the '{@link #getLeft() <em>Left</em>}' containment reference. | ||
| 38 | * <!-- begin-user-doc --> | ||
| 39 | * <!-- end-user-doc --> | ||
| 40 | * @see #getLeft() | ||
| 41 | * @generated | ||
| 42 | * @ordered | ||
| 43 | */ | ||
| 44 | protected Expression left; | ||
| 45 | |||
| 46 | /** | ||
| 47 | * The default value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @see #getOp() | ||
| 51 | * @generated | ||
| 52 | * @ordered | ||
| 53 | */ | ||
| 54 | protected static final BinaryOperator OP_EDEFAULT = BinaryOperator.EQ; | ||
| 55 | |||
| 56 | /** | ||
| 57 | * The cached value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @see #getOp() | ||
| 61 | * @generated | ||
| 62 | * @ordered | ||
| 63 | */ | ||
| 64 | protected BinaryOperator op = OP_EDEFAULT; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * The cached value of the '{@link #getRight() <em>Right</em>}' containment reference. | ||
| 68 | * <!-- begin-user-doc --> | ||
| 69 | * <!-- end-user-doc --> | ||
| 70 | * @see #getRight() | ||
| 71 | * @generated | ||
| 72 | * @ordered | ||
| 73 | */ | ||
| 74 | protected Expression right; | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | protected ComparisonImpl() | ||
| 82 | { | ||
| 83 | super(); | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | protected EClass eStaticClass() | ||
| 93 | { | ||
| 94 | return SolverLanguagePackage.Literals.COMPARISON; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public Expression getLeft() | ||
| 104 | { | ||
| 105 | return left; | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | public NotificationChain basicSetLeft(Expression newLeft, NotificationChain msgs) | ||
| 114 | { | ||
| 115 | Expression oldLeft = left; | ||
| 116 | left = newLeft; | ||
| 117 | if (eNotificationRequired()) | ||
| 118 | { | ||
| 119 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COMPARISON__LEFT, oldLeft, newLeft); | ||
| 120 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 121 | } | ||
| 122 | return msgs; | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void setLeft(Expression newLeft) | ||
| 132 | { | ||
| 133 | if (newLeft != left) | ||
| 134 | { | ||
| 135 | NotificationChain msgs = null; | ||
| 136 | if (left != null) | ||
| 137 | msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COMPARISON__LEFT, null, msgs); | ||
| 138 | if (newLeft != null) | ||
| 139 | msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COMPARISON__LEFT, null, msgs); | ||
| 140 | msgs = basicSetLeft(newLeft, msgs); | ||
| 141 | if (msgs != null) msgs.dispatch(); | ||
| 142 | } | ||
| 143 | else if (eNotificationRequired()) | ||
| 144 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COMPARISON__LEFT, newLeft, newLeft)); | ||
| 145 | } | ||
| 146 | |||
| 147 | /** | ||
| 148 | * <!-- begin-user-doc --> | ||
| 149 | * <!-- end-user-doc --> | ||
| 150 | * @generated | ||
| 151 | */ | ||
| 152 | @Override | ||
| 153 | public BinaryOperator getOp() | ||
| 154 | { | ||
| 155 | return op; | ||
| 156 | } | ||
| 157 | |||
| 158 | /** | ||
| 159 | * <!-- begin-user-doc --> | ||
| 160 | * <!-- end-user-doc --> | ||
| 161 | * @generated | ||
| 162 | */ | ||
| 163 | @Override | ||
| 164 | public void setOp(BinaryOperator newOp) | ||
| 165 | { | ||
| 166 | BinaryOperator oldOp = op; | ||
| 167 | op = newOp == null ? OP_EDEFAULT : newOp; | ||
| 168 | if (eNotificationRequired()) | ||
| 169 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COMPARISON__OP, oldOp, op)); | ||
| 170 | } | ||
| 171 | |||
| 172 | /** | ||
| 173 | * <!-- begin-user-doc --> | ||
| 174 | * <!-- end-user-doc --> | ||
| 175 | * @generated | ||
| 176 | */ | ||
| 177 | @Override | ||
| 178 | public Expression getRight() | ||
| 179 | { | ||
| 180 | return right; | ||
| 181 | } | ||
| 182 | |||
| 183 | /** | ||
| 184 | * <!-- begin-user-doc --> | ||
| 185 | * <!-- end-user-doc --> | ||
| 186 | * @generated | ||
| 187 | */ | ||
| 188 | public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs) | ||
| 189 | { | ||
| 190 | Expression oldRight = right; | ||
| 191 | right = newRight; | ||
| 192 | if (eNotificationRequired()) | ||
| 193 | { | ||
| 194 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COMPARISON__RIGHT, oldRight, newRight); | ||
| 195 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 196 | } | ||
| 197 | return msgs; | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public void setRight(Expression newRight) | ||
| 207 | { | ||
| 208 | if (newRight != right) | ||
| 209 | { | ||
| 210 | NotificationChain msgs = null; | ||
| 211 | if (right != null) | ||
| 212 | msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COMPARISON__RIGHT, null, msgs); | ||
| 213 | if (newRight != null) | ||
| 214 | msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COMPARISON__RIGHT, null, msgs); | ||
| 215 | msgs = basicSetRight(newRight, msgs); | ||
| 216 | if (msgs != null) msgs.dispatch(); | ||
| 217 | } | ||
| 218 | else if (eNotificationRequired()) | ||
| 219 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COMPARISON__RIGHT, newRight, newRight)); | ||
| 220 | } | ||
| 221 | |||
| 222 | /** | ||
| 223 | * <!-- begin-user-doc --> | ||
| 224 | * <!-- end-user-doc --> | ||
| 225 | * @generated | ||
| 226 | */ | ||
| 227 | @Override | ||
| 228 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 229 | { | ||
| 230 | switch (featureID) | ||
| 231 | { | ||
| 232 | case SolverLanguagePackage.COMPARISON__LEFT: | ||
| 233 | return basicSetLeft(null, msgs); | ||
| 234 | case SolverLanguagePackage.COMPARISON__RIGHT: | ||
| 235 | return basicSetRight(null, msgs); | ||
| 236 | } | ||
| 237 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 238 | } | ||
| 239 | |||
| 240 | /** | ||
| 241 | * <!-- begin-user-doc --> | ||
| 242 | * <!-- end-user-doc --> | ||
| 243 | * @generated | ||
| 244 | */ | ||
| 245 | @Override | ||
| 246 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 247 | { | ||
| 248 | switch (featureID) | ||
| 249 | { | ||
| 250 | case SolverLanguagePackage.COMPARISON__LEFT: | ||
| 251 | return getLeft(); | ||
| 252 | case SolverLanguagePackage.COMPARISON__OP: | ||
| 253 | return getOp(); | ||
| 254 | case SolverLanguagePackage.COMPARISON__RIGHT: | ||
| 255 | return getRight(); | ||
| 256 | } | ||
| 257 | return super.eGet(featureID, resolve, coreType); | ||
| 258 | } | ||
| 259 | |||
| 260 | /** | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | @Override | ||
| 266 | public void eSet(int featureID, Object newValue) | ||
| 267 | { | ||
| 268 | switch (featureID) | ||
| 269 | { | ||
| 270 | case SolverLanguagePackage.COMPARISON__LEFT: | ||
| 271 | setLeft((Expression)newValue); | ||
| 272 | return; | ||
| 273 | case SolverLanguagePackage.COMPARISON__OP: | ||
| 274 | setOp((BinaryOperator)newValue); | ||
| 275 | return; | ||
| 276 | case SolverLanguagePackage.COMPARISON__RIGHT: | ||
| 277 | setRight((Expression)newValue); | ||
| 278 | return; | ||
| 279 | } | ||
| 280 | super.eSet(featureID, newValue); | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public void eUnset(int featureID) | ||
| 290 | { | ||
| 291 | switch (featureID) | ||
| 292 | { | ||
| 293 | case SolverLanguagePackage.COMPARISON__LEFT: | ||
| 294 | setLeft((Expression)null); | ||
| 295 | return; | ||
| 296 | case SolverLanguagePackage.COMPARISON__OP: | ||
| 297 | setOp(OP_EDEFAULT); | ||
| 298 | return; | ||
| 299 | case SolverLanguagePackage.COMPARISON__RIGHT: | ||
| 300 | setRight((Expression)null); | ||
| 301 | return; | ||
| 302 | } | ||
| 303 | super.eUnset(featureID); | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public boolean eIsSet(int featureID) | ||
| 313 | { | ||
| 314 | switch (featureID) | ||
| 315 | { | ||
| 316 | case SolverLanguagePackage.COMPARISON__LEFT: | ||
| 317 | return left != null; | ||
| 318 | case SolverLanguagePackage.COMPARISON__OP: | ||
| 319 | return op != OP_EDEFAULT; | ||
| 320 | case SolverLanguagePackage.COMPARISON__RIGHT: | ||
| 321 | return right != null; | ||
| 322 | } | ||
| 323 | return super.eIsSet(featureID); | ||
| 324 | } | ||
| 325 | |||
| 326 | /** | ||
| 327 | * <!-- begin-user-doc --> | ||
| 328 | * <!-- end-user-doc --> | ||
| 329 | * @generated | ||
| 330 | */ | ||
| 331 | @Override | ||
| 332 | public String toString() | ||
| 333 | { | ||
| 334 | if (eIsProxy()) return super.toString(); | ||
| 335 | |||
| 336 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 337 | result.append(" (op: "); | ||
| 338 | result.append(op); | ||
| 339 | result.append(')'); | ||
| 340 | return result.toString(); | ||
| 341 | } | ||
| 342 | |||
| 343 | } //ComparisonImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java deleted file mode 100644 index 09ad8a6d..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java +++ /dev/null | |||
| @@ -1,43 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 9 | |||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | ||
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * <!-- begin-user-doc --> | ||
| 15 | * An implementation of the model object '<em><b>Complex Object</b></em>'. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * | ||
| 18 | * @generated | ||
| 19 | */ | ||
| 20 | public class ComplexObjectImpl extends MinimalEObjectImpl.Container implements ComplexObject | ||
| 21 | { | ||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * <!-- end-user-doc --> | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | protected ComplexObjectImpl() | ||
| 28 | { | ||
| 29 | super(); | ||
| 30 | } | ||
| 31 | |||
| 32 | /** | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | @Override | ||
| 38 | protected EClass eStaticClass() | ||
| 39 | { | ||
| 40 | return SolverLanguagePackage.Literals.COMPLEX_OBJECT; | ||
| 41 | } | ||
| 42 | |||
| 43 | } //ComplexObjectImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConjunctionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConjunctionImpl.java new file mode 100644 index 00000000..6a1e995a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConjunctionImpl.java | |||
| @@ -0,0 +1,167 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.EList; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.EClass; | ||
| 13 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 14 | |||
| 15 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 16 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 17 | |||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 21 | |||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * An implementation of the model object '<em><b>Conjunction</b></em>'. | ||
| 25 | * <!-- end-user-doc --> | ||
| 26 | * <p> | ||
| 27 | * The following features are implemented: | ||
| 28 | * </p> | ||
| 29 | * <ul> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConjunctionImpl#getChildren <em>Children</em>}</li> | ||
| 31 | * </ul> | ||
| 32 | * | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | public class ConjunctionImpl extends ExpressionImpl implements Conjunction | ||
| 36 | { | ||
| 37 | /** | ||
| 38 | * The cached value of the '{@link #getChildren() <em>Children</em>}' containment reference list. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @see #getChildren() | ||
| 42 | * @generated | ||
| 43 | * @ordered | ||
| 44 | */ | ||
| 45 | protected EList<Expression> children; | ||
| 46 | |||
| 47 | /** | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @generated | ||
| 51 | */ | ||
| 52 | protected ConjunctionImpl() | ||
| 53 | { | ||
| 54 | super(); | ||
| 55 | } | ||
| 56 | |||
| 57 | /** | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | @Override | ||
| 63 | protected EClass eStaticClass() | ||
| 64 | { | ||
| 65 | return SolverLanguagePackage.Literals.CONJUNCTION; | ||
| 66 | } | ||
| 67 | |||
| 68 | /** | ||
| 69 | * <!-- begin-user-doc --> | ||
| 70 | * <!-- end-user-doc --> | ||
| 71 | * @generated | ||
| 72 | */ | ||
| 73 | @Override | ||
| 74 | public EList<Expression> getChildren() | ||
| 75 | { | ||
| 76 | if (children == null) | ||
| 77 | { | ||
| 78 | children = new EObjectContainmentEList<Expression>(Expression.class, this, SolverLanguagePackage.CONJUNCTION__CHILDREN); | ||
| 79 | } | ||
| 80 | return children; | ||
| 81 | } | ||
| 82 | |||
| 83 | /** | ||
| 84 | * <!-- begin-user-doc --> | ||
| 85 | * <!-- end-user-doc --> | ||
| 86 | * @generated | ||
| 87 | */ | ||
| 88 | @Override | ||
| 89 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 90 | { | ||
| 91 | switch (featureID) | ||
| 92 | { | ||
| 93 | case SolverLanguagePackage.CONJUNCTION__CHILDREN: | ||
| 94 | return ((InternalEList<?>)getChildren()).basicRemove(otherEnd, msgs); | ||
| 95 | } | ||
| 96 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 97 | } | ||
| 98 | |||
| 99 | /** | ||
| 100 | * <!-- begin-user-doc --> | ||
| 101 | * <!-- end-user-doc --> | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | @Override | ||
| 105 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 106 | { | ||
| 107 | switch (featureID) | ||
| 108 | { | ||
| 109 | case SolverLanguagePackage.CONJUNCTION__CHILDREN: | ||
| 110 | return getChildren(); | ||
| 111 | } | ||
| 112 | return super.eGet(featureID, resolve, coreType); | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * <!-- begin-user-doc --> | ||
| 117 | * <!-- end-user-doc --> | ||
| 118 | * @generated | ||
| 119 | */ | ||
| 120 | @SuppressWarnings("unchecked") | ||
| 121 | @Override | ||
| 122 | public void eSet(int featureID, Object newValue) | ||
| 123 | { | ||
| 124 | switch (featureID) | ||
| 125 | { | ||
| 126 | case SolverLanguagePackage.CONJUNCTION__CHILDREN: | ||
| 127 | getChildren().clear(); | ||
| 128 | getChildren().addAll((Collection<? extends Expression>)newValue); | ||
| 129 | return; | ||
| 130 | } | ||
| 131 | super.eSet(featureID, newValue); | ||
| 132 | } | ||
| 133 | |||
| 134 | /** | ||
| 135 | * <!-- begin-user-doc --> | ||
| 136 | * <!-- end-user-doc --> | ||
| 137 | * @generated | ||
| 138 | */ | ||
| 139 | @Override | ||
| 140 | public void eUnset(int featureID) | ||
| 141 | { | ||
| 142 | switch (featureID) | ||
| 143 | { | ||
| 144 | case SolverLanguagePackage.CONJUNCTION__CHILDREN: | ||
| 145 | getChildren().clear(); | ||
| 146 | return; | ||
| 147 | } | ||
| 148 | super.eUnset(featureID); | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * <!-- begin-user-doc --> | ||
| 153 | * <!-- end-user-doc --> | ||
| 154 | * @generated | ||
| 155 | */ | ||
| 156 | @Override | ||
| 157 | public boolean eIsSet(int featureID) | ||
| 158 | { | ||
| 159 | switch (featureID) | ||
| 160 | { | ||
| 161 | case SolverLanguagePackage.CONJUNCTION__CHILDREN: | ||
| 162 | return children != null && !children.isEmpty(); | ||
| 163 | } | ||
| 164 | return super.eIsSet(featureID); | ||
| 165 | } | ||
| 166 | |||
| 167 | } //ConjunctionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java deleted file mode 100644 index 2f990fee..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java +++ /dev/null | |||
| @@ -1,393 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 18 | |||
| 19 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 20 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 21 | |||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | ||
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 28 | |||
| 29 | /** | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * An implementation of the model object '<em><b>Constraint</b></em>'. | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * <p> | ||
| 34 | * The following features are implemented: | ||
| 35 | * </p> | ||
| 36 | * <ul> | ||
| 37 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getPolarity <em>Polarity</em>}</li> | ||
| 38 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getSymbol <em>Symbol</em>}</li> | ||
| 39 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getParams <em>Params</em>}</li> | ||
| 40 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getClosureType <em>Closure Type</em>}</li> | ||
| 41 | * </ul> | ||
| 42 | * | ||
| 43 | * @generated | ||
| 44 | */ | ||
| 45 | public class ConstraintImpl extends MinimalEObjectImpl.Container implements Constraint | ||
| 46 | { | ||
| 47 | /** | ||
| 48 | * The cached value of the '{@link #getPolarity() <em>Polarity</em>}' containment reference. | ||
| 49 | * <!-- begin-user-doc --> | ||
| 50 | * <!-- end-user-doc --> | ||
| 51 | * @see #getPolarity() | ||
| 52 | * @generated | ||
| 53 | * @ordered | ||
| 54 | */ | ||
| 55 | protected Polarity polarity; | ||
| 56 | |||
| 57 | /** | ||
| 58 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 59 | * <!-- begin-user-doc --> | ||
| 60 | * <!-- end-user-doc --> | ||
| 61 | * @see #getSymbol() | ||
| 62 | * @generated | ||
| 63 | * @ordered | ||
| 64 | */ | ||
| 65 | protected ModelSymbol symbol; | ||
| 66 | |||
| 67 | /** | ||
| 68 | * The cached value of the '{@link #getParams() <em>Params</em>}' containment reference list. | ||
| 69 | * <!-- begin-user-doc --> | ||
| 70 | * <!-- end-user-doc --> | ||
| 71 | * @see #getParams() | ||
| 72 | * @generated | ||
| 73 | * @ordered | ||
| 74 | */ | ||
| 75 | protected EList<Literal> params; | ||
| 76 | |||
| 77 | /** | ||
| 78 | * The cached value of the '{@link #getClosureType() <em>Closure Type</em>}' containment reference. | ||
| 79 | * <!-- begin-user-doc --> | ||
| 80 | * <!-- end-user-doc --> | ||
| 81 | * @see #getClosureType() | ||
| 82 | * @generated | ||
| 83 | * @ordered | ||
| 84 | */ | ||
| 85 | protected ClosureType closureType; | ||
| 86 | |||
| 87 | /** | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | protected ConstraintImpl() | ||
| 93 | { | ||
| 94 | super(); | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | protected EClass eStaticClass() | ||
| 104 | { | ||
| 105 | return SolverLanguagePackage.Literals.CONSTRAINT; | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | @Override | ||
| 114 | public Polarity getPolarity() | ||
| 115 | { | ||
| 116 | return polarity; | ||
| 117 | } | ||
| 118 | |||
| 119 | /** | ||
| 120 | * <!-- begin-user-doc --> | ||
| 121 | * <!-- end-user-doc --> | ||
| 122 | * @generated | ||
| 123 | */ | ||
| 124 | public NotificationChain basicSetPolarity(Polarity newPolarity, NotificationChain msgs) | ||
| 125 | { | ||
| 126 | Polarity oldPolarity = polarity; | ||
| 127 | polarity = newPolarity; | ||
| 128 | if (eNotificationRequired()) | ||
| 129 | { | ||
| 130 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, oldPolarity, newPolarity); | ||
| 131 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 132 | } | ||
| 133 | return msgs; | ||
| 134 | } | ||
| 135 | |||
| 136 | /** | ||
| 137 | * <!-- begin-user-doc --> | ||
| 138 | * <!-- end-user-doc --> | ||
| 139 | * @generated | ||
| 140 | */ | ||
| 141 | @Override | ||
| 142 | public void setPolarity(Polarity newPolarity) | ||
| 143 | { | ||
| 144 | if (newPolarity != polarity) | ||
| 145 | { | ||
| 146 | NotificationChain msgs = null; | ||
| 147 | if (polarity != null) | ||
| 148 | msgs = ((InternalEObject)polarity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs); | ||
| 149 | if (newPolarity != null) | ||
| 150 | msgs = ((InternalEObject)newPolarity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs); | ||
| 151 | msgs = basicSetPolarity(newPolarity, msgs); | ||
| 152 | if (msgs != null) msgs.dispatch(); | ||
| 153 | } | ||
| 154 | else if (eNotificationRequired()) | ||
| 155 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, newPolarity, newPolarity)); | ||
| 156 | } | ||
| 157 | |||
| 158 | /** | ||
| 159 | * <!-- begin-user-doc --> | ||
| 160 | * <!-- end-user-doc --> | ||
| 161 | * @generated | ||
| 162 | */ | ||
| 163 | @Override | ||
| 164 | public ModelSymbol getSymbol() | ||
| 165 | { | ||
| 166 | return symbol; | ||
| 167 | } | ||
| 168 | |||
| 169 | /** | ||
| 170 | * <!-- begin-user-doc --> | ||
| 171 | * <!-- end-user-doc --> | ||
| 172 | * @generated | ||
| 173 | */ | ||
| 174 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 175 | { | ||
| 176 | ModelSymbol oldSymbol = symbol; | ||
| 177 | symbol = newSymbol; | ||
| 178 | if (eNotificationRequired()) | ||
| 179 | { | ||
| 180 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, oldSymbol, newSymbol); | ||
| 181 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 182 | } | ||
| 183 | return msgs; | ||
| 184 | } | ||
| 185 | |||
| 186 | /** | ||
| 187 | * <!-- begin-user-doc --> | ||
| 188 | * <!-- end-user-doc --> | ||
| 189 | * @generated | ||
| 190 | */ | ||
| 191 | @Override | ||
| 192 | public void setSymbol(ModelSymbol newSymbol) | ||
| 193 | { | ||
| 194 | if (newSymbol != symbol) | ||
| 195 | { | ||
| 196 | NotificationChain msgs = null; | ||
| 197 | if (symbol != null) | ||
| 198 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs); | ||
| 199 | if (newSymbol != null) | ||
| 200 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs); | ||
| 201 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 202 | if (msgs != null) msgs.dispatch(); | ||
| 203 | } | ||
| 204 | else if (eNotificationRequired()) | ||
| 205 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, newSymbol, newSymbol)); | ||
| 206 | } | ||
| 207 | |||
| 208 | /** | ||
| 209 | * <!-- begin-user-doc --> | ||
| 210 | * <!-- end-user-doc --> | ||
| 211 | * @generated | ||
| 212 | */ | ||
| 213 | @Override | ||
| 214 | public EList<Literal> getParams() | ||
| 215 | { | ||
| 216 | if (params == null) | ||
| 217 | { | ||
| 218 | params = new EObjectContainmentEList<Literal>(Literal.class, this, SolverLanguagePackage.CONSTRAINT__PARAMS); | ||
| 219 | } | ||
| 220 | return params; | ||
| 221 | } | ||
| 222 | |||
| 223 | /** | ||
| 224 | * <!-- begin-user-doc --> | ||
| 225 | * <!-- end-user-doc --> | ||
| 226 | * @generated | ||
| 227 | */ | ||
| 228 | @Override | ||
| 229 | public ClosureType getClosureType() | ||
| 230 | { | ||
| 231 | return closureType; | ||
| 232 | } | ||
| 233 | |||
| 234 | /** | ||
| 235 | * <!-- begin-user-doc --> | ||
| 236 | * <!-- end-user-doc --> | ||
| 237 | * @generated | ||
| 238 | */ | ||
| 239 | public NotificationChain basicSetClosureType(ClosureType newClosureType, NotificationChain msgs) | ||
| 240 | { | ||
| 241 | ClosureType oldClosureType = closureType; | ||
| 242 | closureType = newClosureType; | ||
| 243 | if (eNotificationRequired()) | ||
| 244 | { | ||
| 245 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, oldClosureType, newClosureType); | ||
| 246 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 247 | } | ||
| 248 | return msgs; | ||
| 249 | } | ||
| 250 | |||
| 251 | /** | ||
| 252 | * <!-- begin-user-doc --> | ||
| 253 | * <!-- end-user-doc --> | ||
| 254 | * @generated | ||
| 255 | */ | ||
| 256 | @Override | ||
| 257 | public void setClosureType(ClosureType newClosureType) | ||
| 258 | { | ||
| 259 | if (newClosureType != closureType) | ||
| 260 | { | ||
| 261 | NotificationChain msgs = null; | ||
| 262 | if (closureType != null) | ||
| 263 | msgs = ((InternalEObject)closureType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs); | ||
| 264 | if (newClosureType != null) | ||
| 265 | msgs = ((InternalEObject)newClosureType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs); | ||
| 266 | msgs = basicSetClosureType(newClosureType, msgs); | ||
| 267 | if (msgs != null) msgs.dispatch(); | ||
| 268 | } | ||
| 269 | else if (eNotificationRequired()) | ||
| 270 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, newClosureType, newClosureType)); | ||
| 271 | } | ||
| 272 | |||
| 273 | /** | ||
| 274 | * <!-- begin-user-doc --> | ||
| 275 | * <!-- end-user-doc --> | ||
| 276 | * @generated | ||
| 277 | */ | ||
| 278 | @Override | ||
| 279 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 280 | { | ||
| 281 | switch (featureID) | ||
| 282 | { | ||
| 283 | case SolverLanguagePackage.CONSTRAINT__POLARITY: | ||
| 284 | return basicSetPolarity(null, msgs); | ||
| 285 | case SolverLanguagePackage.CONSTRAINT__SYMBOL: | ||
| 286 | return basicSetSymbol(null, msgs); | ||
| 287 | case SolverLanguagePackage.CONSTRAINT__PARAMS: | ||
| 288 | return ((InternalEList<?>)getParams()).basicRemove(otherEnd, msgs); | ||
| 289 | case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: | ||
| 290 | return basicSetClosureType(null, msgs); | ||
| 291 | } | ||
| 292 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 293 | } | ||
| 294 | |||
| 295 | /** | ||
| 296 | * <!-- begin-user-doc --> | ||
| 297 | * <!-- end-user-doc --> | ||
| 298 | * @generated | ||
| 299 | */ | ||
| 300 | @Override | ||
| 301 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 302 | { | ||
| 303 | switch (featureID) | ||
| 304 | { | ||
| 305 | case SolverLanguagePackage.CONSTRAINT__POLARITY: | ||
| 306 | return getPolarity(); | ||
| 307 | case SolverLanguagePackage.CONSTRAINT__SYMBOL: | ||
| 308 | return getSymbol(); | ||
| 309 | case SolverLanguagePackage.CONSTRAINT__PARAMS: | ||
| 310 | return getParams(); | ||
| 311 | case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: | ||
| 312 | return getClosureType(); | ||
| 313 | } | ||
| 314 | return super.eGet(featureID, resolve, coreType); | ||
| 315 | } | ||
| 316 | |||
| 317 | /** | ||
| 318 | * <!-- begin-user-doc --> | ||
| 319 | * <!-- end-user-doc --> | ||
| 320 | * @generated | ||
| 321 | */ | ||
| 322 | @SuppressWarnings("unchecked") | ||
| 323 | @Override | ||
| 324 | public void eSet(int featureID, Object newValue) | ||
| 325 | { | ||
| 326 | switch (featureID) | ||
| 327 | { | ||
| 328 | case SolverLanguagePackage.CONSTRAINT__POLARITY: | ||
| 329 | setPolarity((Polarity)newValue); | ||
| 330 | return; | ||
| 331 | case SolverLanguagePackage.CONSTRAINT__SYMBOL: | ||
| 332 | setSymbol((ModelSymbol)newValue); | ||
| 333 | return; | ||
| 334 | case SolverLanguagePackage.CONSTRAINT__PARAMS: | ||
| 335 | getParams().clear(); | ||
| 336 | getParams().addAll((Collection<? extends Literal>)newValue); | ||
| 337 | return; | ||
| 338 | case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: | ||
| 339 | setClosureType((ClosureType)newValue); | ||
| 340 | return; | ||
| 341 | } | ||
| 342 | super.eSet(featureID, newValue); | ||
| 343 | } | ||
| 344 | |||
| 345 | /** | ||
| 346 | * <!-- begin-user-doc --> | ||
| 347 | * <!-- end-user-doc --> | ||
| 348 | * @generated | ||
| 349 | */ | ||
| 350 | @Override | ||
| 351 | public void eUnset(int featureID) | ||
| 352 | { | ||
| 353 | switch (featureID) | ||
| 354 | { | ||
| 355 | case SolverLanguagePackage.CONSTRAINT__POLARITY: | ||
| 356 | setPolarity((Polarity)null); | ||
| 357 | return; | ||
| 358 | case SolverLanguagePackage.CONSTRAINT__SYMBOL: | ||
| 359 | setSymbol((ModelSymbol)null); | ||
| 360 | return; | ||
| 361 | case SolverLanguagePackage.CONSTRAINT__PARAMS: | ||
| 362 | getParams().clear(); | ||
| 363 | return; | ||
| 364 | case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: | ||
| 365 | setClosureType((ClosureType)null); | ||
| 366 | return; | ||
| 367 | } | ||
| 368 | super.eUnset(featureID); | ||
| 369 | } | ||
| 370 | |||
| 371 | /** | ||
| 372 | * <!-- begin-user-doc --> | ||
| 373 | * <!-- end-user-doc --> | ||
| 374 | * @generated | ||
| 375 | */ | ||
| 376 | @Override | ||
| 377 | public boolean eIsSet(int featureID) | ||
| 378 | { | ||
| 379 | switch (featureID) | ||
| 380 | { | ||
| 381 | case SolverLanguagePackage.CONSTRAINT__POLARITY: | ||
| 382 | return polarity != null; | ||
| 383 | case SolverLanguagePackage.CONSTRAINT__SYMBOL: | ||
| 384 | return symbol != null; | ||
| 385 | case SolverLanguagePackage.CONSTRAINT__PARAMS: | ||
| 386 | return params != null && !params.isEmpty(); | ||
| 387 | case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: | ||
| 388 | return closureType != null; | ||
| 389 | } | ||
| 390 | return super.eIsSet(featureID); | ||
| 391 | } | ||
| 392 | |||
| 393 | } //ConstraintImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CountImpl.java index 5da3bf30..1609245f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CountImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -11,41 +11,41 @@ import org.eclipse.emf.ecore.InternalEObject; | |||
| 11 | 11 | ||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 13 | 13 | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.Count; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 17 | 17 | ||
| 18 | /** | 18 | /** |
| 19 | * <!-- begin-user-doc --> | 19 | * <!-- begin-user-doc --> |
| 20 | * An implementation of the model object '<em><b>All Instances</b></em>'. | 20 | * An implementation of the model object '<em><b>Count</b></em>'. |
| 21 | * <!-- end-user-doc --> | 21 | * <!-- end-user-doc --> |
| 22 | * <p> | 22 | * <p> |
| 23 | * The following features are implemented: | 23 | * The following features are implemented: |
| 24 | * </p> | 24 | * </p> |
| 25 | * <ul> | 25 | * <ul> |
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl#getSymbol <em>Symbol</em>}</li> | 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CountImpl#getBody <em>Body</em>}</li> |
| 27 | * </ul> | 27 | * </ul> |
| 28 | * | 28 | * |
| 29 | * @generated | 29 | * @generated |
| 30 | */ | 30 | */ |
| 31 | public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | 31 | public class CountImpl extends ExpressionImpl implements Count |
| 32 | { | 32 | { |
| 33 | /** | 33 | /** |
| 34 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | 34 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. |
| 35 | * <!-- begin-user-doc --> | 35 | * <!-- begin-user-doc --> |
| 36 | * <!-- end-user-doc --> | 36 | * <!-- end-user-doc --> |
| 37 | * @see #getSymbol() | 37 | * @see #getBody() |
| 38 | * @generated | 38 | * @generated |
| 39 | * @ordered | 39 | * @ordered |
| 40 | */ | 40 | */ |
| 41 | protected Symbol symbol; | 41 | protected Expression body; |
| 42 | 42 | ||
| 43 | /** | 43 | /** |
| 44 | * <!-- begin-user-doc --> | 44 | * <!-- begin-user-doc --> |
| 45 | * <!-- end-user-doc --> | 45 | * <!-- end-user-doc --> |
| 46 | * @generated | 46 | * @generated |
| 47 | */ | 47 | */ |
| 48 | protected AllInstancesImpl() | 48 | protected CountImpl() |
| 49 | { | 49 | { |
| 50 | super(); | 50 | super(); |
| 51 | } | 51 | } |
| @@ -58,7 +58,7 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 58 | @Override | 58 | @Override |
| 59 | protected EClass eStaticClass() | 59 | protected EClass eStaticClass() |
| 60 | { | 60 | { |
| 61 | return SolverLanguagePackage.Literals.ALL_INSTANCES; | 61 | return SolverLanguagePackage.Literals.COUNT; |
| 62 | } | 62 | } |
| 63 | 63 | ||
| 64 | /** | 64 | /** |
| @@ -67,9 +67,9 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 67 | * @generated | 67 | * @generated |
| 68 | */ | 68 | */ |
| 69 | @Override | 69 | @Override |
| 70 | public Symbol getSymbol() | 70 | public Expression getBody() |
| 71 | { | 71 | { |
| 72 | return symbol; | 72 | return body; |
| 73 | } | 73 | } |
| 74 | 74 | ||
| 75 | /** | 75 | /** |
| @@ -77,13 +77,13 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 77 | * <!-- end-user-doc --> | 77 | * <!-- end-user-doc --> |
| 78 | * @generated | 78 | * @generated |
| 79 | */ | 79 | */ |
| 80 | public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs) | 80 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) |
| 81 | { | 81 | { |
| 82 | Symbol oldSymbol = symbol; | 82 | Expression oldBody = body; |
| 83 | symbol = newSymbol; | 83 | body = newBody; |
| 84 | if (eNotificationRequired()) | 84 | if (eNotificationRequired()) |
| 85 | { | 85 | { |
| 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, oldSymbol, newSymbol); | 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COUNT__BODY, oldBody, newBody); |
| 87 | if (msgs == null) msgs = notification; else msgs.add(notification); | 87 | if (msgs == null) msgs = notification; else msgs.add(notification); |
| 88 | } | 88 | } |
| 89 | return msgs; | 89 | return msgs; |
| @@ -95,20 +95,20 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 95 | * @generated | 95 | * @generated |
| 96 | */ | 96 | */ |
| 97 | @Override | 97 | @Override |
| 98 | public void setSymbol(Symbol newSymbol) | 98 | public void setBody(Expression newBody) |
| 99 | { | 99 | { |
| 100 | if (newSymbol != symbol) | 100 | if (newBody != body) |
| 101 | { | 101 | { |
| 102 | NotificationChain msgs = null; | 102 | NotificationChain msgs = null; |
| 103 | if (symbol != null) | 103 | if (body != null) |
| 104 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs); | 104 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COUNT__BODY, null, msgs); |
| 105 | if (newSymbol != null) | 105 | if (newBody != null) |
| 106 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs); | 106 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.COUNT__BODY, null, msgs); |
| 107 | msgs = basicSetSymbol(newSymbol, msgs); | 107 | msgs = basicSetBody(newBody, msgs); |
| 108 | if (msgs != null) msgs.dispatch(); | 108 | if (msgs != null) msgs.dispatch(); |
| 109 | } | 109 | } |
| 110 | else if (eNotificationRequired()) | 110 | else if (eNotificationRequired()) |
| 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, newSymbol, newSymbol)); | 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.COUNT__BODY, newBody, newBody)); |
| 112 | } | 112 | } |
| 113 | 113 | ||
| 114 | /** | 114 | /** |
| @@ -121,8 +121,8 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 121 | { | 121 | { |
| 122 | switch (featureID) | 122 | switch (featureID) |
| 123 | { | 123 | { |
| 124 | case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: | 124 | case SolverLanguagePackage.COUNT__BODY: |
| 125 | return basicSetSymbol(null, msgs); | 125 | return basicSetBody(null, msgs); |
| 126 | } | 126 | } |
| 127 | return super.eInverseRemove(otherEnd, featureID, msgs); | 127 | return super.eInverseRemove(otherEnd, featureID, msgs); |
| 128 | } | 128 | } |
| @@ -137,8 +137,8 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 137 | { | 137 | { |
| 138 | switch (featureID) | 138 | switch (featureID) |
| 139 | { | 139 | { |
| 140 | case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: | 140 | case SolverLanguagePackage.COUNT__BODY: |
| 141 | return getSymbol(); | 141 | return getBody(); |
| 142 | } | 142 | } |
| 143 | return super.eGet(featureID, resolve, coreType); | 143 | return super.eGet(featureID, resolve, coreType); |
| 144 | } | 144 | } |
| @@ -153,8 +153,8 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 153 | { | 153 | { |
| 154 | switch (featureID) | 154 | switch (featureID) |
| 155 | { | 155 | { |
| 156 | case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: | 156 | case SolverLanguagePackage.COUNT__BODY: |
| 157 | setSymbol((Symbol)newValue); | 157 | setBody((Expression)newValue); |
| 158 | return; | 158 | return; |
| 159 | } | 159 | } |
| 160 | super.eSet(featureID, newValue); | 160 | super.eSet(featureID, newValue); |
| @@ -170,8 +170,8 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 170 | { | 170 | { |
| 171 | switch (featureID) | 171 | switch (featureID) |
| 172 | { | 172 | { |
| 173 | case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: | 173 | case SolverLanguagePackage.COUNT__BODY: |
| 174 | setSymbol((Symbol)null); | 174 | setBody((Expression)null); |
| 175 | return; | 175 | return; |
| 176 | } | 176 | } |
| 177 | super.eUnset(featureID); | 177 | super.eUnset(featureID); |
| @@ -187,10 +187,10 @@ public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances | |||
| 187 | { | 187 | { |
| 188 | switch (featureID) | 188 | switch (featureID) |
| 189 | { | 189 | { |
| 190 | case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: | 190 | case SolverLanguagePackage.COUNT__BODY: |
| 191 | return symbol != null; | 191 | return body != null; |
| 192 | } | 192 | } |
| 193 | return super.eIsSet(featureID); | 193 | return super.eIsSet(featureID); |
| 194 | } | 194 | } |
| 195 | 195 | ||
| 196 | } //AllInstancesImpl | 196 | } //CountImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java deleted file mode 100644 index 33bee29f..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.DataObject; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Data Object</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class DataObjectImpl extends ObjectImpl implements DataObject | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected DataObjectImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.DATA_OBJECT; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //DataObjectImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java deleted file mode 100644 index 221b4783..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Data Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class DataSymbolImpl extends SymbolImpl implements DataSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected DataSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.DATA_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //DataSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultDefinitionImpl.java new file mode 100644 index 00000000..c1eaa71a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultDefinitionImpl.java | |||
| @@ -0,0 +1,270 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Call; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Default Definition</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl#getHead <em>Head</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultDefinitionImpl#getRange <em>Range</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class DefaultDefinitionImpl extends StatementImpl implements DefaultDefinition | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The cached value of the '{@link #getHead() <em>Head</em>}' containment reference. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getHead() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected Call head; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getRange() <em>Range</em>}' containment reference. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getRange() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected Expression range; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | protected DefaultDefinitionImpl() | ||
| 61 | { | ||
| 62 | super(); | ||
| 63 | } | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | @Override | ||
| 71 | protected EClass eStaticClass() | ||
| 72 | { | ||
| 73 | return SolverLanguagePackage.Literals.DEFAULT_DEFINITION; | ||
| 74 | } | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | @Override | ||
| 82 | public Call getHead() | ||
| 83 | { | ||
| 84 | return head; | ||
| 85 | } | ||
| 86 | |||
| 87 | /** | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | public NotificationChain basicSetHead(Call newHead, NotificationChain msgs) | ||
| 93 | { | ||
| 94 | Call oldHead = head; | ||
| 95 | head = newHead; | ||
| 96 | if (eNotificationRequired()) | ||
| 97 | { | ||
| 98 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_DEFINITION__HEAD, oldHead, newHead); | ||
| 99 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 100 | } | ||
| 101 | return msgs; | ||
| 102 | } | ||
| 103 | |||
| 104 | /** | ||
| 105 | * <!-- begin-user-doc --> | ||
| 106 | * <!-- end-user-doc --> | ||
| 107 | * @generated | ||
| 108 | */ | ||
| 109 | @Override | ||
| 110 | public void setHead(Call newHead) | ||
| 111 | { | ||
| 112 | if (newHead != head) | ||
| 113 | { | ||
| 114 | NotificationChain msgs = null; | ||
| 115 | if (head != null) | ||
| 116 | msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_DEFINITION__HEAD, null, msgs); | ||
| 117 | if (newHead != null) | ||
| 118 | msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_DEFINITION__HEAD, null, msgs); | ||
| 119 | msgs = basicSetHead(newHead, msgs); | ||
| 120 | if (msgs != null) msgs.dispatch(); | ||
| 121 | } | ||
| 122 | else if (eNotificationRequired()) | ||
| 123 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_DEFINITION__HEAD, newHead, newHead)); | ||
| 124 | } | ||
| 125 | |||
| 126 | /** | ||
| 127 | * <!-- begin-user-doc --> | ||
| 128 | * <!-- end-user-doc --> | ||
| 129 | * @generated | ||
| 130 | */ | ||
| 131 | @Override | ||
| 132 | public Expression getRange() | ||
| 133 | { | ||
| 134 | return range; | ||
| 135 | } | ||
| 136 | |||
| 137 | /** | ||
| 138 | * <!-- begin-user-doc --> | ||
| 139 | * <!-- end-user-doc --> | ||
| 140 | * @generated | ||
| 141 | */ | ||
| 142 | public NotificationChain basicSetRange(Expression newRange, NotificationChain msgs) | ||
| 143 | { | ||
| 144 | Expression oldRange = range; | ||
| 145 | range = newRange; | ||
| 146 | if (eNotificationRequired()) | ||
| 147 | { | ||
| 148 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_DEFINITION__RANGE, oldRange, newRange); | ||
| 149 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 150 | } | ||
| 151 | return msgs; | ||
| 152 | } | ||
| 153 | |||
| 154 | /** | ||
| 155 | * <!-- begin-user-doc --> | ||
| 156 | * <!-- end-user-doc --> | ||
| 157 | * @generated | ||
| 158 | */ | ||
| 159 | @Override | ||
| 160 | public void setRange(Expression newRange) | ||
| 161 | { | ||
| 162 | if (newRange != range) | ||
| 163 | { | ||
| 164 | NotificationChain msgs = null; | ||
| 165 | if (range != null) | ||
| 166 | msgs = ((InternalEObject)range).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_DEFINITION__RANGE, null, msgs); | ||
| 167 | if (newRange != null) | ||
| 168 | msgs = ((InternalEObject)newRange).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_DEFINITION__RANGE, null, msgs); | ||
| 169 | msgs = basicSetRange(newRange, msgs); | ||
| 170 | if (msgs != null) msgs.dispatch(); | ||
| 171 | } | ||
| 172 | else if (eNotificationRequired()) | ||
| 173 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_DEFINITION__RANGE, newRange, newRange)); | ||
| 174 | } | ||
| 175 | |||
| 176 | /** | ||
| 177 | * <!-- begin-user-doc --> | ||
| 178 | * <!-- end-user-doc --> | ||
| 179 | * @generated | ||
| 180 | */ | ||
| 181 | @Override | ||
| 182 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 183 | { | ||
| 184 | switch (featureID) | ||
| 185 | { | ||
| 186 | case SolverLanguagePackage.DEFAULT_DEFINITION__HEAD: | ||
| 187 | return basicSetHead(null, msgs); | ||
| 188 | case SolverLanguagePackage.DEFAULT_DEFINITION__RANGE: | ||
| 189 | return basicSetRange(null, msgs); | ||
| 190 | } | ||
| 191 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 192 | } | ||
| 193 | |||
| 194 | /** | ||
| 195 | * <!-- begin-user-doc --> | ||
| 196 | * <!-- end-user-doc --> | ||
| 197 | * @generated | ||
| 198 | */ | ||
| 199 | @Override | ||
| 200 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 201 | { | ||
| 202 | switch (featureID) | ||
| 203 | { | ||
| 204 | case SolverLanguagePackage.DEFAULT_DEFINITION__HEAD: | ||
| 205 | return getHead(); | ||
| 206 | case SolverLanguagePackage.DEFAULT_DEFINITION__RANGE: | ||
| 207 | return getRange(); | ||
| 208 | } | ||
| 209 | return super.eGet(featureID, resolve, coreType); | ||
| 210 | } | ||
| 211 | |||
| 212 | /** | ||
| 213 | * <!-- begin-user-doc --> | ||
| 214 | * <!-- end-user-doc --> | ||
| 215 | * @generated | ||
| 216 | */ | ||
| 217 | @Override | ||
| 218 | public void eSet(int featureID, Object newValue) | ||
| 219 | { | ||
| 220 | switch (featureID) | ||
| 221 | { | ||
| 222 | case SolverLanguagePackage.DEFAULT_DEFINITION__HEAD: | ||
| 223 | setHead((Call)newValue); | ||
| 224 | return; | ||
| 225 | case SolverLanguagePackage.DEFAULT_DEFINITION__RANGE: | ||
| 226 | setRange((Expression)newValue); | ||
| 227 | return; | ||
| 228 | } | ||
| 229 | super.eSet(featureID, newValue); | ||
| 230 | } | ||
| 231 | |||
| 232 | /** | ||
| 233 | * <!-- begin-user-doc --> | ||
| 234 | * <!-- end-user-doc --> | ||
| 235 | * @generated | ||
| 236 | */ | ||
| 237 | @Override | ||
| 238 | public void eUnset(int featureID) | ||
| 239 | { | ||
| 240 | switch (featureID) | ||
| 241 | { | ||
| 242 | case SolverLanguagePackage.DEFAULT_DEFINITION__HEAD: | ||
| 243 | setHead((Call)null); | ||
| 244 | return; | ||
| 245 | case SolverLanguagePackage.DEFAULT_DEFINITION__RANGE: | ||
| 246 | setRange((Expression)null); | ||
| 247 | return; | ||
| 248 | } | ||
| 249 | super.eUnset(featureID); | ||
| 250 | } | ||
| 251 | |||
| 252 | /** | ||
| 253 | * <!-- begin-user-doc --> | ||
| 254 | * <!-- end-user-doc --> | ||
| 255 | * @generated | ||
| 256 | */ | ||
| 257 | @Override | ||
| 258 | public boolean eIsSet(int featureID) | ||
| 259 | { | ||
| 260 | switch (featureID) | ||
| 261 | { | ||
| 262 | case SolverLanguagePackage.DEFAULT_DEFINITION__HEAD: | ||
| 263 | return head != null; | ||
| 264 | case SolverLanguagePackage.DEFAULT_DEFINITION__RANGE: | ||
| 265 | return range != null; | ||
| 266 | } | ||
| 267 | return super.eIsSet(featureID); | ||
| 268 | } | ||
| 269 | |||
| 270 | } //DefaultDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DisjunctionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DisjunctionImpl.java new file mode 100644 index 00000000..ecdb14d8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DisjunctionImpl.java | |||
| @@ -0,0 +1,167 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.EList; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.EClass; | ||
| 13 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 14 | |||
| 15 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 16 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 17 | |||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 21 | |||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * An implementation of the model object '<em><b>Disjunction</b></em>'. | ||
| 25 | * <!-- end-user-doc --> | ||
| 26 | * <p> | ||
| 27 | * The following features are implemented: | ||
| 28 | * </p> | ||
| 29 | * <ul> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DisjunctionImpl#getChildren <em>Children</em>}</li> | ||
| 31 | * </ul> | ||
| 32 | * | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | public class DisjunctionImpl extends ExpressionImpl implements Disjunction | ||
| 36 | { | ||
| 37 | /** | ||
| 38 | * The cached value of the '{@link #getChildren() <em>Children</em>}' containment reference list. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @see #getChildren() | ||
| 42 | * @generated | ||
| 43 | * @ordered | ||
| 44 | */ | ||
| 45 | protected EList<Expression> children; | ||
| 46 | |||
| 47 | /** | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @generated | ||
| 51 | */ | ||
| 52 | protected DisjunctionImpl() | ||
| 53 | { | ||
| 54 | super(); | ||
| 55 | } | ||
| 56 | |||
| 57 | /** | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | @Override | ||
| 63 | protected EClass eStaticClass() | ||
| 64 | { | ||
| 65 | return SolverLanguagePackage.Literals.DISJUNCTION; | ||
| 66 | } | ||
| 67 | |||
| 68 | /** | ||
| 69 | * <!-- begin-user-doc --> | ||
| 70 | * <!-- end-user-doc --> | ||
| 71 | * @generated | ||
| 72 | */ | ||
| 73 | @Override | ||
| 74 | public EList<Expression> getChildren() | ||
| 75 | { | ||
| 76 | if (children == null) | ||
| 77 | { | ||
| 78 | children = new EObjectContainmentEList<Expression>(Expression.class, this, SolverLanguagePackage.DISJUNCTION__CHILDREN); | ||
| 79 | } | ||
| 80 | return children; | ||
| 81 | } | ||
| 82 | |||
| 83 | /** | ||
| 84 | * <!-- begin-user-doc --> | ||
| 85 | * <!-- end-user-doc --> | ||
| 86 | * @generated | ||
| 87 | */ | ||
| 88 | @Override | ||
| 89 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 90 | { | ||
| 91 | switch (featureID) | ||
| 92 | { | ||
| 93 | case SolverLanguagePackage.DISJUNCTION__CHILDREN: | ||
| 94 | return ((InternalEList<?>)getChildren()).basicRemove(otherEnd, msgs); | ||
| 95 | } | ||
| 96 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 97 | } | ||
| 98 | |||
| 99 | /** | ||
| 100 | * <!-- begin-user-doc --> | ||
| 101 | * <!-- end-user-doc --> | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | @Override | ||
| 105 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 106 | { | ||
| 107 | switch (featureID) | ||
| 108 | { | ||
| 109 | case SolverLanguagePackage.DISJUNCTION__CHILDREN: | ||
| 110 | return getChildren(); | ||
| 111 | } | ||
| 112 | return super.eGet(featureID, resolve, coreType); | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * <!-- begin-user-doc --> | ||
| 117 | * <!-- end-user-doc --> | ||
| 118 | * @generated | ||
| 119 | */ | ||
| 120 | @SuppressWarnings("unchecked") | ||
| 121 | @Override | ||
| 122 | public void eSet(int featureID, Object newValue) | ||
| 123 | { | ||
| 124 | switch (featureID) | ||
| 125 | { | ||
| 126 | case SolverLanguagePackage.DISJUNCTION__CHILDREN: | ||
| 127 | getChildren().clear(); | ||
| 128 | getChildren().addAll((Collection<? extends Expression>)newValue); | ||
| 129 | return; | ||
| 130 | } | ||
| 131 | super.eSet(featureID, newValue); | ||
| 132 | } | ||
| 133 | |||
| 134 | /** | ||
| 135 | * <!-- begin-user-doc --> | ||
| 136 | * <!-- end-user-doc --> | ||
| 137 | * @generated | ||
| 138 | */ | ||
| 139 | @Override | ||
| 140 | public void eUnset(int featureID) | ||
| 141 | { | ||
| 142 | switch (featureID) | ||
| 143 | { | ||
| 144 | case SolverLanguagePackage.DISJUNCTION__CHILDREN: | ||
| 145 | getChildren().clear(); | ||
| 146 | return; | ||
| 147 | } | ||
| 148 | super.eUnset(featureID); | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * <!-- begin-user-doc --> | ||
| 153 | * <!-- end-user-doc --> | ||
| 154 | * @generated | ||
| 155 | */ | ||
| 156 | @Override | ||
| 157 | public boolean eIsSet(int featureID) | ||
| 158 | { | ||
| 159 | switch (featureID) | ||
| 160 | { | ||
| 161 | case SolverLanguagePackage.DISJUNCTION__CHILDREN: | ||
| 162 | return children != null && !children.isEmpty(); | ||
| 163 | } | ||
| 164 | return super.eIsSet(featureID); | ||
| 165 | } | ||
| 166 | |||
| 167 | } //DisjunctionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EmptyIntervalLiteralImpl.java index 44195feb..1ebf38ad 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EmptyIntervalLiteralImpl.java | |||
| @@ -1,28 +1,28 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral; | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | ||
| 10 | 10 | ||
| 11 | /** | 11 | /** |
| 12 | * <!-- begin-user-doc --> | 12 | * <!-- begin-user-doc --> |
| 13 | * An implementation of the model object '<em><b>Unknown</b></em>'. | 13 | * An implementation of the model object '<em><b>Empty Interval Literal</b></em>'. |
| 14 | * <!-- end-user-doc --> | 14 | * <!-- end-user-doc --> |
| 15 | * | 15 | * |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public class UnknownImpl extends TruthValueImpl implements Unknown | 18 | public class EmptyIntervalLiteralImpl extends LiteralImpl implements EmptyIntervalLiteral |
| 19 | { | 19 | { |
| 20 | /** | 20 | /** |
| 21 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
| 22 | * <!-- end-user-doc --> | 22 | * <!-- end-user-doc --> |
| 23 | * @generated | 23 | * @generated |
| 24 | */ | 24 | */ |
| 25 | protected UnknownImpl() | 25 | protected EmptyIntervalLiteralImpl() |
| 26 | { | 26 | { |
| 27 | super(); | 27 | super(); |
| 28 | } | 28 | } |
| @@ -35,7 +35,7 @@ public class UnknownImpl extends TruthValueImpl implements Unknown | |||
| 35 | @Override | 35 | @Override |
| 36 | protected EClass eStaticClass() | 36 | protected EClass eStaticClass() |
| 37 | { | 37 | { |
| 38 | return SolverLanguagePackage.Literals.UNKNOWN; | 38 | return SolverLanguagePackage.Literals.EMPTY_INTERVAL_LITERAL; |
| 39 | } | 39 | } |
| 40 | 40 | ||
| 41 | } //UnknownImpl | 41 | } //EmptyIntervalLiteralImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java deleted file mode 100644 index efa12ea6..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java +++ /dev/null | |||
| @@ -1,244 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | |||
| 18 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 19 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 20 | |||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 25 | |||
| 26 | /** | ||
| 27 | * <!-- begin-user-doc --> | ||
| 28 | * An implementation of the model object '<em><b>Enum Interpretation</b></em>'. | ||
| 29 | * <!-- end-user-doc --> | ||
| 30 | * <p> | ||
| 31 | * The following features are implemented: | ||
| 32 | * </p> | ||
| 33 | * <ul> | ||
| 34 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getSymbol <em>Symbol</em>}</li> | ||
| 35 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getObjects <em>Objects</em>}</li> | ||
| 36 | * </ul> | ||
| 37 | * | ||
| 38 | * @generated | ||
| 39 | */ | ||
| 40 | public class EnumInterpretationImpl extends CDInterpretationImpl implements EnumInterpretation | ||
| 41 | { | ||
| 42 | /** | ||
| 43 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 44 | * <!-- begin-user-doc --> | ||
| 45 | * <!-- end-user-doc --> | ||
| 46 | * @see #getSymbol() | ||
| 47 | * @generated | ||
| 48 | * @ordered | ||
| 49 | */ | ||
| 50 | protected ModelSymbol symbol; | ||
| 51 | |||
| 52 | /** | ||
| 53 | * The cached value of the '{@link #getObjects() <em>Objects</em>}' containment reference list. | ||
| 54 | * <!-- begin-user-doc --> | ||
| 55 | * <!-- end-user-doc --> | ||
| 56 | * @see #getObjects() | ||
| 57 | * @generated | ||
| 58 | * @ordered | ||
| 59 | */ | ||
| 60 | protected EList<NamedObject> objects; | ||
| 61 | |||
| 62 | /** | ||
| 63 | * <!-- begin-user-doc --> | ||
| 64 | * <!-- end-user-doc --> | ||
| 65 | * @generated | ||
| 66 | */ | ||
| 67 | protected EnumInterpretationImpl() | ||
| 68 | { | ||
| 69 | super(); | ||
| 70 | } | ||
| 71 | |||
| 72 | /** | ||
| 73 | * <!-- begin-user-doc --> | ||
| 74 | * <!-- end-user-doc --> | ||
| 75 | * @generated | ||
| 76 | */ | ||
| 77 | @Override | ||
| 78 | protected EClass eStaticClass() | ||
| 79 | { | ||
| 80 | return SolverLanguagePackage.Literals.ENUM_INTERPRETATION; | ||
| 81 | } | ||
| 82 | |||
| 83 | /** | ||
| 84 | * <!-- begin-user-doc --> | ||
| 85 | * <!-- end-user-doc --> | ||
| 86 | * @generated | ||
| 87 | */ | ||
| 88 | @Override | ||
| 89 | public ModelSymbol getSymbol() | ||
| 90 | { | ||
| 91 | return symbol; | ||
| 92 | } | ||
| 93 | |||
| 94 | /** | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @generated | ||
| 98 | */ | ||
| 99 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 100 | { | ||
| 101 | ModelSymbol oldSymbol = symbol; | ||
| 102 | symbol = newSymbol; | ||
| 103 | if (eNotificationRequired()) | ||
| 104 | { | ||
| 105 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); | ||
| 106 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 107 | } | ||
| 108 | return msgs; | ||
| 109 | } | ||
| 110 | |||
| 111 | /** | ||
| 112 | * <!-- begin-user-doc --> | ||
| 113 | * <!-- end-user-doc --> | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | @Override | ||
| 117 | public void setSymbol(ModelSymbol newSymbol) | ||
| 118 | { | ||
| 119 | if (newSymbol != symbol) | ||
| 120 | { | ||
| 121 | NotificationChain msgs = null; | ||
| 122 | if (symbol != null) | ||
| 123 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs); | ||
| 124 | if (newSymbol != null) | ||
| 125 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs); | ||
| 126 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 127 | if (msgs != null) msgs.dispatch(); | ||
| 128 | } | ||
| 129 | else if (eNotificationRequired()) | ||
| 130 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); | ||
| 131 | } | ||
| 132 | |||
| 133 | /** | ||
| 134 | * <!-- begin-user-doc --> | ||
| 135 | * <!-- end-user-doc --> | ||
| 136 | * @generated | ||
| 137 | */ | ||
| 138 | @Override | ||
| 139 | public EList<NamedObject> getObjects() | ||
| 140 | { | ||
| 141 | if (objects == null) | ||
| 142 | { | ||
| 143 | objects = new EObjectContainmentEList<NamedObject>(NamedObject.class, this, SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS); | ||
| 144 | } | ||
| 145 | return objects; | ||
| 146 | } | ||
| 147 | |||
| 148 | /** | ||
| 149 | * <!-- begin-user-doc --> | ||
| 150 | * <!-- end-user-doc --> | ||
| 151 | * @generated | ||
| 152 | */ | ||
| 153 | @Override | ||
| 154 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 155 | { | ||
| 156 | switch (featureID) | ||
| 157 | { | ||
| 158 | case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: | ||
| 159 | return basicSetSymbol(null, msgs); | ||
| 160 | case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: | ||
| 161 | return ((InternalEList<?>)getObjects()).basicRemove(otherEnd, msgs); | ||
| 162 | } | ||
| 163 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 164 | } | ||
| 165 | |||
| 166 | /** | ||
| 167 | * <!-- begin-user-doc --> | ||
| 168 | * <!-- end-user-doc --> | ||
| 169 | * @generated | ||
| 170 | */ | ||
| 171 | @Override | ||
| 172 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 173 | { | ||
| 174 | switch (featureID) | ||
| 175 | { | ||
| 176 | case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: | ||
| 177 | return getSymbol(); | ||
| 178 | case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: | ||
| 179 | return getObjects(); | ||
| 180 | } | ||
| 181 | return super.eGet(featureID, resolve, coreType); | ||
| 182 | } | ||
| 183 | |||
| 184 | /** | ||
| 185 | * <!-- begin-user-doc --> | ||
| 186 | * <!-- end-user-doc --> | ||
| 187 | * @generated | ||
| 188 | */ | ||
| 189 | @SuppressWarnings("unchecked") | ||
| 190 | @Override | ||
| 191 | public void eSet(int featureID, Object newValue) | ||
| 192 | { | ||
| 193 | switch (featureID) | ||
| 194 | { | ||
| 195 | case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: | ||
| 196 | setSymbol((ModelSymbol)newValue); | ||
| 197 | return; | ||
| 198 | case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: | ||
| 199 | getObjects().clear(); | ||
| 200 | getObjects().addAll((Collection<? extends NamedObject>)newValue); | ||
| 201 | return; | ||
| 202 | } | ||
| 203 | super.eSet(featureID, newValue); | ||
| 204 | } | ||
| 205 | |||
| 206 | /** | ||
| 207 | * <!-- begin-user-doc --> | ||
| 208 | * <!-- end-user-doc --> | ||
| 209 | * @generated | ||
| 210 | */ | ||
| 211 | @Override | ||
| 212 | public void eUnset(int featureID) | ||
| 213 | { | ||
| 214 | switch (featureID) | ||
| 215 | { | ||
| 216 | case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: | ||
| 217 | setSymbol((ModelSymbol)null); | ||
| 218 | return; | ||
| 219 | case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: | ||
| 220 | getObjects().clear(); | ||
| 221 | return; | ||
| 222 | } | ||
| 223 | super.eUnset(featureID); | ||
| 224 | } | ||
| 225 | |||
| 226 | /** | ||
| 227 | * <!-- begin-user-doc --> | ||
| 228 | * <!-- end-user-doc --> | ||
| 229 | * @generated | ||
| 230 | */ | ||
| 231 | @Override | ||
| 232 | public boolean eIsSet(int featureID) | ||
| 233 | { | ||
| 234 | switch (featureID) | ||
| 235 | { | ||
| 236 | case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: | ||
| 237 | return symbol != null; | ||
| 238 | case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: | ||
| 239 | return objects != null && !objects.isEmpty(); | ||
| 240 | } | ||
| 241 | return super.eIsSet(featureID); | ||
| 242 | } | ||
| 243 | |||
| 244 | } //EnumInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java deleted file mode 100644 index 33929f42..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Equals Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class EqualsSymbolImpl extends PartialitySymbolImpl implements EqualsSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected EqualsSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.EQUALS_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //EqualsSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java deleted file mode 100644 index e58094a7..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java +++ /dev/null | |||
| @@ -1,40 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 9 | |||
| 10 | /** | ||
| 11 | * <!-- begin-user-doc --> | ||
| 12 | * An implementation of the model object '<em><b>Error</b></em>'. | ||
| 13 | * <!-- end-user-doc --> | ||
| 14 | * | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public class ErrorImpl extends TruthValueImpl implements org.eclipse.viatra.solver.language.solverLanguage.Error | ||
| 18 | { | ||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | protected ErrorImpl() | ||
| 25 | { | ||
| 26 | super(); | ||
| 27 | } | ||
| 28 | |||
| 29 | /** | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | @Override | ||
| 35 | protected EClass eStaticClass() | ||
| 36 | { | ||
| 37 | return SolverLanguagePackage.Literals.ERROR; | ||
| 38 | } | ||
| 39 | |||
| 40 | } //ErrorImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExactMultiplicityImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExactMultiplicityImpl.java new file mode 100644 index 00000000..3751de39 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExactMultiplicityImpl.java | |||
| @@ -0,0 +1,179 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Exact Multiplicity</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactMultiplicityImpl#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 24 | * </ul> | ||
| 25 | * | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public class ExactMultiplicityImpl extends MultiplicityImpl implements ExactMultiplicity | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * The default value of the '{@link #getMultiplicity() <em>Multiplicity</em>}' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @see #getMultiplicity() | ||
| 35 | * @generated | ||
| 36 | * @ordered | ||
| 37 | */ | ||
| 38 | protected static final int MULTIPLICITY_EDEFAULT = 0; | ||
| 39 | |||
| 40 | /** | ||
| 41 | * The cached value of the '{@link #getMultiplicity() <em>Multiplicity</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @see #getMultiplicity() | ||
| 45 | * @generated | ||
| 46 | * @ordered | ||
| 47 | */ | ||
| 48 | protected int multiplicity = MULTIPLICITY_EDEFAULT; | ||
| 49 | |||
| 50 | /** | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @generated | ||
| 54 | */ | ||
| 55 | protected ExactMultiplicityImpl() | ||
| 56 | { | ||
| 57 | super(); | ||
| 58 | } | ||
| 59 | |||
| 60 | /** | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @generated | ||
| 64 | */ | ||
| 65 | @Override | ||
| 66 | protected EClass eStaticClass() | ||
| 67 | { | ||
| 68 | return SolverLanguagePackage.Literals.EXACT_MULTIPLICITY; | ||
| 69 | } | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | @Override | ||
| 77 | public int getMultiplicity() | ||
| 78 | { | ||
| 79 | return multiplicity; | ||
| 80 | } | ||
| 81 | |||
| 82 | /** | ||
| 83 | * <!-- begin-user-doc --> | ||
| 84 | * <!-- end-user-doc --> | ||
| 85 | * @generated | ||
| 86 | */ | ||
| 87 | @Override | ||
| 88 | public void setMultiplicity(int newMultiplicity) | ||
| 89 | { | ||
| 90 | int oldMultiplicity = multiplicity; | ||
| 91 | multiplicity = newMultiplicity; | ||
| 92 | if (eNotificationRequired()) | ||
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXACT_MULTIPLICITY__MULTIPLICITY, oldMultiplicity, multiplicity)); | ||
| 94 | } | ||
| 95 | |||
| 96 | /** | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @generated | ||
| 100 | */ | ||
| 101 | @Override | ||
| 102 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 103 | { | ||
| 104 | switch (featureID) | ||
| 105 | { | ||
| 106 | case SolverLanguagePackage.EXACT_MULTIPLICITY__MULTIPLICITY: | ||
| 107 | return getMultiplicity(); | ||
| 108 | } | ||
| 109 | return super.eGet(featureID, resolve, coreType); | ||
| 110 | } | ||
| 111 | |||
| 112 | /** | ||
| 113 | * <!-- begin-user-doc --> | ||
| 114 | * <!-- end-user-doc --> | ||
| 115 | * @generated | ||
| 116 | */ | ||
| 117 | @Override | ||
| 118 | public void eSet(int featureID, Object newValue) | ||
| 119 | { | ||
| 120 | switch (featureID) | ||
| 121 | { | ||
| 122 | case SolverLanguagePackage.EXACT_MULTIPLICITY__MULTIPLICITY: | ||
| 123 | setMultiplicity((Integer)newValue); | ||
| 124 | return; | ||
| 125 | } | ||
| 126 | super.eSet(featureID, newValue); | ||
| 127 | } | ||
| 128 | |||
| 129 | /** | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @generated | ||
| 133 | */ | ||
| 134 | @Override | ||
| 135 | public void eUnset(int featureID) | ||
| 136 | { | ||
| 137 | switch (featureID) | ||
| 138 | { | ||
| 139 | case SolverLanguagePackage.EXACT_MULTIPLICITY__MULTIPLICITY: | ||
| 140 | setMultiplicity(MULTIPLICITY_EDEFAULT); | ||
| 141 | return; | ||
| 142 | } | ||
| 143 | super.eUnset(featureID); | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | @Override | ||
| 152 | public boolean eIsSet(int featureID) | ||
| 153 | { | ||
| 154 | switch (featureID) | ||
| 155 | { | ||
| 156 | case SolverLanguagePackage.EXACT_MULTIPLICITY__MULTIPLICITY: | ||
| 157 | return multiplicity != MULTIPLICITY_EDEFAULT; | ||
| 158 | } | ||
| 159 | return super.eIsSet(featureID); | ||
| 160 | } | ||
| 161 | |||
| 162 | /** | ||
| 163 | * <!-- begin-user-doc --> | ||
| 164 | * <!-- end-user-doc --> | ||
| 165 | * @generated | ||
| 166 | */ | ||
| 167 | @Override | ||
| 168 | public String toString() | ||
| 169 | { | ||
| 170 | if (eIsProxy()) return super.toString(); | ||
| 171 | |||
| 172 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 173 | result.append(" (multiplicity: "); | ||
| 174 | result.append(multiplicity); | ||
| 175 | result.append(')'); | ||
| 176 | return result.toString(); | ||
| 177 | } | ||
| 178 | |||
| 179 | } //ExactMultiplicityImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExactScopeDefinitionImpl.java index bd195572..faf51904 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExactScopeDefinitionImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -9,50 +9,50 @@ import org.eclipse.emf.ecore.EClass; | |||
| 9 | 9 | ||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 11 | 11 | ||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition; |
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 14 | 14 | ||
| 15 | /** | 15 | /** |
| 16 | * <!-- begin-user-doc --> | 16 | * <!-- begin-user-doc --> |
| 17 | * An implementation of the model object '<em><b>Model Symbol</b></em>'. | 17 | * An implementation of the model object '<em><b>Exact Scope Definition</b></em>'. |
| 18 | * <!-- end-user-doc --> | 18 | * <!-- end-user-doc --> |
| 19 | * <p> | 19 | * <p> |
| 20 | * The following features are implemented: | 20 | * The following features are implemented: |
| 21 | * </p> | 21 | * </p> |
| 22 | * <ul> | 22 | * <ul> |
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl#getName <em>Name</em>}</li> | 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExactScopeDefinitionImpl#getExactScope <em>Exact Scope</em>}</li> |
| 24 | * </ul> | 24 | * </ul> |
| 25 | * | 25 | * |
| 26 | * @generated | 26 | * @generated |
| 27 | */ | 27 | */ |
| 28 | public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | 28 | public class ExactScopeDefinitionImpl extends ScopeDefinitionImpl implements ExactScopeDefinition |
| 29 | { | 29 | { |
| 30 | /** | 30 | /** |
| 31 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | 31 | * The default value of the '{@link #getExactScope() <em>Exact Scope</em>}' attribute. |
| 32 | * <!-- begin-user-doc --> | 32 | * <!-- begin-user-doc --> |
| 33 | * <!-- end-user-doc --> | 33 | * <!-- end-user-doc --> |
| 34 | * @see #getName() | 34 | * @see #getExactScope() |
| 35 | * @generated | 35 | * @generated |
| 36 | * @ordered | 36 | * @ordered |
| 37 | */ | 37 | */ |
| 38 | protected static final String NAME_EDEFAULT = null; | 38 | protected static final int EXACT_SCOPE_EDEFAULT = 0; |
| 39 | 39 | ||
| 40 | /** | 40 | /** |
| 41 | * The cached value of the '{@link #getName() <em>Name</em>}' attribute. | 41 | * The cached value of the '{@link #getExactScope() <em>Exact Scope</em>}' attribute. |
| 42 | * <!-- begin-user-doc --> | 42 | * <!-- begin-user-doc --> |
| 43 | * <!-- end-user-doc --> | 43 | * <!-- end-user-doc --> |
| 44 | * @see #getName() | 44 | * @see #getExactScope() |
| 45 | * @generated | 45 | * @generated |
| 46 | * @ordered | 46 | * @ordered |
| 47 | */ | 47 | */ |
| 48 | protected String name = NAME_EDEFAULT; | 48 | protected int exactScope = EXACT_SCOPE_EDEFAULT; |
| 49 | 49 | ||
| 50 | /** | 50 | /** |
| 51 | * <!-- begin-user-doc --> | 51 | * <!-- begin-user-doc --> |
| 52 | * <!-- end-user-doc --> | 52 | * <!-- end-user-doc --> |
| 53 | * @generated | 53 | * @generated |
| 54 | */ | 54 | */ |
| 55 | protected ModelSymbolImpl() | 55 | protected ExactScopeDefinitionImpl() |
| 56 | { | 56 | { |
| 57 | super(); | 57 | super(); |
| 58 | } | 58 | } |
| @@ -65,7 +65,7 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 65 | @Override | 65 | @Override |
| 66 | protected EClass eStaticClass() | 66 | protected EClass eStaticClass() |
| 67 | { | 67 | { |
| 68 | return SolverLanguagePackage.Literals.MODEL_SYMBOL; | 68 | return SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION; |
| 69 | } | 69 | } |
| 70 | 70 | ||
| 71 | /** | 71 | /** |
| @@ -74,9 +74,9 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 74 | * @generated | 74 | * @generated |
| 75 | */ | 75 | */ |
| 76 | @Override | 76 | @Override |
| 77 | public String getName() | 77 | public int getExactScope() |
| 78 | { | 78 | { |
| 79 | return name; | 79 | return exactScope; |
| 80 | } | 80 | } |
| 81 | 81 | ||
| 82 | /** | 82 | /** |
| @@ -85,12 +85,12 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 85 | * @generated | 85 | * @generated |
| 86 | */ | 86 | */ |
| 87 | @Override | 87 | @Override |
| 88 | public void setName(String newName) | 88 | public void setExactScope(int newExactScope) |
| 89 | { | 89 | { |
| 90 | String oldName = name; | 90 | int oldExactScope = exactScope; |
| 91 | name = newName; | 91 | exactScope = newExactScope; |
| 92 | if (eNotificationRequired()) | 92 | if (eNotificationRequired()) |
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MODEL_SYMBOL__NAME, oldName, name)); | 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXACT_SCOPE_DEFINITION__EXACT_SCOPE, oldExactScope, exactScope)); |
| 94 | } | 94 | } |
| 95 | 95 | ||
| 96 | /** | 96 | /** |
| @@ -103,8 +103,8 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 103 | { | 103 | { |
| 104 | switch (featureID) | 104 | switch (featureID) |
| 105 | { | 105 | { |
| 106 | case SolverLanguagePackage.MODEL_SYMBOL__NAME: | 106 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION__EXACT_SCOPE: |
| 107 | return getName(); | 107 | return getExactScope(); |
| 108 | } | 108 | } |
| 109 | return super.eGet(featureID, resolve, coreType); | 109 | return super.eGet(featureID, resolve, coreType); |
| 110 | } | 110 | } |
| @@ -119,8 +119,8 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 119 | { | 119 | { |
| 120 | switch (featureID) | 120 | switch (featureID) |
| 121 | { | 121 | { |
| 122 | case SolverLanguagePackage.MODEL_SYMBOL__NAME: | 122 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION__EXACT_SCOPE: |
| 123 | setName((String)newValue); | 123 | setExactScope((Integer)newValue); |
| 124 | return; | 124 | return; |
| 125 | } | 125 | } |
| 126 | super.eSet(featureID, newValue); | 126 | super.eSet(featureID, newValue); |
| @@ -136,8 +136,8 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 136 | { | 136 | { |
| 137 | switch (featureID) | 137 | switch (featureID) |
| 138 | { | 138 | { |
| 139 | case SolverLanguagePackage.MODEL_SYMBOL__NAME: | 139 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION__EXACT_SCOPE: |
| 140 | setName(NAME_EDEFAULT); | 140 | setExactScope(EXACT_SCOPE_EDEFAULT); |
| 141 | return; | 141 | return; |
| 142 | } | 142 | } |
| 143 | super.eUnset(featureID); | 143 | super.eUnset(featureID); |
| @@ -153,8 +153,8 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 153 | { | 153 | { |
| 154 | switch (featureID) | 154 | switch (featureID) |
| 155 | { | 155 | { |
| 156 | case SolverLanguagePackage.MODEL_SYMBOL__NAME: | 156 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION__EXACT_SCOPE: |
| 157 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | 157 | return exactScope != EXACT_SCOPE_EDEFAULT; |
| 158 | } | 158 | } |
| 159 | return super.eIsSet(featureID); | 159 | return super.eIsSet(featureID); |
| 160 | } | 160 | } |
| @@ -170,10 +170,10 @@ public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol | |||
| 170 | if (eIsProxy()) return super.toString(); | 170 | if (eIsProxy()) return super.toString(); |
| 171 | 171 | ||
| 172 | StringBuilder result = new StringBuilder(super.toString()); | 172 | StringBuilder result = new StringBuilder(super.toString()); |
| 173 | result.append(" (name: "); | 173 | result.append(" (exactScope: "); |
| 174 | result.append(name); | 174 | result.append(exactScope); |
| 175 | result.append(')'); | 175 | result.append(')'); |
| 176 | return result.toString(); | 176 | return result.toString(); |
| 177 | } | 177 | } |
| 178 | 178 | ||
| 179 | } //ModelSymbolImpl | 179 | } //ExactScopeDefinitionImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java deleted file mode 100644 index 2fd59e41..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Exist Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class ExistSymbolImpl extends PartialitySymbolImpl implements ExistSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected ExistSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.EXIST_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //ExistSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExpressionArgumentImpl.java index cb1a3ff4..f83c1cb3 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExpressionArgumentImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -11,41 +11,41 @@ import org.eclipse.emf.ecore.InternalEObject; | |||
| 11 | 11 | ||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 13 | 13 | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; |
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 17 | 17 | ||
| 18 | /** | 18 | /** |
| 19 | * <!-- begin-user-doc --> | 19 | * <!-- begin-user-doc --> |
| 20 | * An implementation of the model object '<em><b>Boolean Object</b></em>'. | 20 | * An implementation of the model object '<em><b>Expression Argument</b></em>'. |
| 21 | * <!-- end-user-doc --> | 21 | * <!-- end-user-doc --> |
| 22 | * <p> | 22 | * <p> |
| 23 | * The following features are implemented: | 23 | * The following features are implemented: |
| 24 | * </p> | 24 | * </p> |
| 25 | * <ul> | 25 | * <ul> |
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl#getValue <em>Value</em>}</li> | 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExpressionArgumentImpl#getBody <em>Body</em>}</li> |
| 27 | * </ul> | 27 | * </ul> |
| 28 | * | 28 | * |
| 29 | * @generated | 29 | * @generated |
| 30 | */ | 30 | */ |
| 31 | public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | 31 | public class ExpressionArgumentImpl extends ArgumentImpl implements ExpressionArgument |
| 32 | { | 32 | { |
| 33 | /** | 33 | /** |
| 34 | * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference. | 34 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. |
| 35 | * <!-- begin-user-doc --> | 35 | * <!-- begin-user-doc --> |
| 36 | * <!-- end-user-doc --> | 36 | * <!-- end-user-doc --> |
| 37 | * @see #getValue() | 37 | * @see #getBody() |
| 38 | * @generated | 38 | * @generated |
| 39 | * @ordered | 39 | * @ordered |
| 40 | */ | 40 | */ |
| 41 | protected BooleanValue value; | 41 | protected Expression body; |
| 42 | 42 | ||
| 43 | /** | 43 | /** |
| 44 | * <!-- begin-user-doc --> | 44 | * <!-- begin-user-doc --> |
| 45 | * <!-- end-user-doc --> | 45 | * <!-- end-user-doc --> |
| 46 | * @generated | 46 | * @generated |
| 47 | */ | 47 | */ |
| 48 | protected BooleanObjectImpl() | 48 | protected ExpressionArgumentImpl() |
| 49 | { | 49 | { |
| 50 | super(); | 50 | super(); |
| 51 | } | 51 | } |
| @@ -58,7 +58,7 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 58 | @Override | 58 | @Override |
| 59 | protected EClass eStaticClass() | 59 | protected EClass eStaticClass() |
| 60 | { | 60 | { |
| 61 | return SolverLanguagePackage.Literals.BOOLEAN_OBJECT; | 61 | return SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT; |
| 62 | } | 62 | } |
| 63 | 63 | ||
| 64 | /** | 64 | /** |
| @@ -67,9 +67,9 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 67 | * @generated | 67 | * @generated |
| 68 | */ | 68 | */ |
| 69 | @Override | 69 | @Override |
| 70 | public BooleanValue getValue() | 70 | public Expression getBody() |
| 71 | { | 71 | { |
| 72 | return value; | 72 | return body; |
| 73 | } | 73 | } |
| 74 | 74 | ||
| 75 | /** | 75 | /** |
| @@ -77,13 +77,13 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 77 | * <!-- end-user-doc --> | 77 | * <!-- end-user-doc --> |
| 78 | * @generated | 78 | * @generated |
| 79 | */ | 79 | */ |
| 80 | public NotificationChain basicSetValue(BooleanValue newValue, NotificationChain msgs) | 80 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) |
| 81 | { | 81 | { |
| 82 | BooleanValue oldValue = value; | 82 | Expression oldBody = body; |
| 83 | value = newValue; | 83 | body = newBody; |
| 84 | if (eNotificationRequired()) | 84 | if (eNotificationRequired()) |
| 85 | { | 85 | { |
| 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, oldValue, newValue); | 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY, oldBody, newBody); |
| 87 | if (msgs == null) msgs = notification; else msgs.add(notification); | 87 | if (msgs == null) msgs = notification; else msgs.add(notification); |
| 88 | } | 88 | } |
| 89 | return msgs; | 89 | return msgs; |
| @@ -95,20 +95,20 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 95 | * @generated | 95 | * @generated |
| 96 | */ | 96 | */ |
| 97 | @Override | 97 | @Override |
| 98 | public void setValue(BooleanValue newValue) | 98 | public void setBody(Expression newBody) |
| 99 | { | 99 | { |
| 100 | if (newValue != value) | 100 | if (newBody != body) |
| 101 | { | 101 | { |
| 102 | NotificationChain msgs = null; | 102 | NotificationChain msgs = null; |
| 103 | if (value != null) | 103 | if (body != null) |
| 104 | msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs); | 104 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY, null, msgs); |
| 105 | if (newValue != null) | 105 | if (newBody != null) |
| 106 | msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs); | 106 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY, null, msgs); |
| 107 | msgs = basicSetValue(newValue, msgs); | 107 | msgs = basicSetBody(newBody, msgs); |
| 108 | if (msgs != null) msgs.dispatch(); | 108 | if (msgs != null) msgs.dispatch(); |
| 109 | } | 109 | } |
| 110 | else if (eNotificationRequired()) | 110 | else if (eNotificationRequired()) |
| 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, newValue, newValue)); | 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY, newBody, newBody)); |
| 112 | } | 112 | } |
| 113 | 113 | ||
| 114 | /** | 114 | /** |
| @@ -121,8 +121,8 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 121 | { | 121 | { |
| 122 | switch (featureID) | 122 | switch (featureID) |
| 123 | { | 123 | { |
| 124 | case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: | 124 | case SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY: |
| 125 | return basicSetValue(null, msgs); | 125 | return basicSetBody(null, msgs); |
| 126 | } | 126 | } |
| 127 | return super.eInverseRemove(otherEnd, featureID, msgs); | 127 | return super.eInverseRemove(otherEnd, featureID, msgs); |
| 128 | } | 128 | } |
| @@ -137,8 +137,8 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 137 | { | 137 | { |
| 138 | switch (featureID) | 138 | switch (featureID) |
| 139 | { | 139 | { |
| 140 | case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: | 140 | case SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY: |
| 141 | return getValue(); | 141 | return getBody(); |
| 142 | } | 142 | } |
| 143 | return super.eGet(featureID, resolve, coreType); | 143 | return super.eGet(featureID, resolve, coreType); |
| 144 | } | 144 | } |
| @@ -153,8 +153,8 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 153 | { | 153 | { |
| 154 | switch (featureID) | 154 | switch (featureID) |
| 155 | { | 155 | { |
| 156 | case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: | 156 | case SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY: |
| 157 | setValue((BooleanValue)newValue); | 157 | setBody((Expression)newValue); |
| 158 | return; | 158 | return; |
| 159 | } | 159 | } |
| 160 | super.eSet(featureID, newValue); | 160 | super.eSet(featureID, newValue); |
| @@ -170,8 +170,8 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 170 | { | 170 | { |
| 171 | switch (featureID) | 171 | switch (featureID) |
| 172 | { | 172 | { |
| 173 | case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: | 173 | case SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY: |
| 174 | setValue((BooleanValue)null); | 174 | setBody((Expression)null); |
| 175 | return; | 175 | return; |
| 176 | } | 176 | } |
| 177 | super.eUnset(featureID); | 177 | super.eUnset(featureID); |
| @@ -187,10 +187,10 @@ public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject | |||
| 187 | { | 187 | { |
| 188 | switch (featureID) | 188 | switch (featureID) |
| 189 | { | 189 | { |
| 190 | case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: | 190 | case SolverLanguagePackage.EXPRESSION_ARGUMENT__BODY: |
| 191 | return value != null; | 191 | return body != null; |
| 192 | } | 192 | } |
| 193 | return super.eIsSet(featureID); | 193 | return super.eIsSet(featureID); |
| 194 | } | 194 | } |
| 195 | 195 | ||
| 196 | } //BooleanObjectImpl | 196 | } //ExpressionArgumentImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExpressionImpl.java index a30b228f..585e3c41 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExpressionImpl.java | |||
| @@ -1,28 +1,28 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | 8 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; |
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 10 | 10 | ||
| 11 | /** | 11 | /** |
| 12 | * <!-- begin-user-doc --> | 12 | * <!-- begin-user-doc --> |
| 13 | * An implementation of the model object '<em><b>Negative</b></em>'. | 13 | * An implementation of the model object '<em><b>Expression</b></em>'. |
| 14 | * <!-- end-user-doc --> | 14 | * <!-- end-user-doc --> |
| 15 | * | 15 | * |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public class NegativeImpl extends PolarityImpl implements Negative | 18 | public class ExpressionImpl extends StatementImpl implements Expression |
| 19 | { | 19 | { |
| 20 | /** | 20 | /** |
| 21 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
| 22 | * <!-- end-user-doc --> | 22 | * <!-- end-user-doc --> |
| 23 | * @generated | 23 | * @generated |
| 24 | */ | 24 | */ |
| 25 | protected NegativeImpl() | 25 | protected ExpressionImpl() |
| 26 | { | 26 | { |
| 27 | super(); | 27 | super(); |
| 28 | } | 28 | } |
| @@ -35,7 +35,7 @@ public class NegativeImpl extends PolarityImpl implements Negative | |||
| 35 | @Override | 35 | @Override |
| 36 | protected EClass eStaticClass() | 36 | protected EClass eStaticClass() |
| 37 | { | 37 | { |
| 38 | return SolverLanguagePackage.Literals.NEGATIVE; | 38 | return SolverLanguagePackage.Literals.EXPRESSION; |
| 39 | } | 39 | } |
| 40 | 40 | ||
| 41 | } //NegativeImpl | 41 | } //ExpressionImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExternMetricDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExternMetricDefinitionImpl.java new file mode 100644 index 00000000..e324c38a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExternMetricDefinitionImpl.java | |||
| @@ -0,0 +1,270 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Call; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.MetricType; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Extern Metric Definition</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl#getType <em>Type</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternMetricDefinitionImpl#getHead <em>Head</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class ExternMetricDefinitionImpl extends StatementImpl implements ExternMetricDefinition | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The default value of the '{@link #getType() <em>Type</em>}' attribute. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getType() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected static final MetricType TYPE_EDEFAULT = MetricType.INT; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getType() <em>Type</em>}' attribute. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getType() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected MetricType type = TYPE_EDEFAULT; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #getHead() <em>Head</em>}' containment reference. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #getHead() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected Call head; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | protected ExternMetricDefinitionImpl() | ||
| 71 | { | ||
| 72 | super(); | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | protected EClass eStaticClass() | ||
| 82 | { | ||
| 83 | return SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | public MetricType getType() | ||
| 93 | { | ||
| 94 | return type; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public void setType(MetricType newType) | ||
| 104 | { | ||
| 105 | MetricType oldType = type; | ||
| 106 | type = newType == null ? TYPE_EDEFAULT : newType; | ||
| 107 | if (eNotificationRequired()) | ||
| 108 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXTERN_METRIC_DEFINITION__TYPE, oldType, type)); | ||
| 109 | } | ||
| 110 | |||
| 111 | /** | ||
| 112 | * <!-- begin-user-doc --> | ||
| 113 | * <!-- end-user-doc --> | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | @Override | ||
| 117 | public Call getHead() | ||
| 118 | { | ||
| 119 | return head; | ||
| 120 | } | ||
| 121 | |||
| 122 | /** | ||
| 123 | * <!-- begin-user-doc --> | ||
| 124 | * <!-- end-user-doc --> | ||
| 125 | * @generated | ||
| 126 | */ | ||
| 127 | public NotificationChain basicSetHead(Call newHead, NotificationChain msgs) | ||
| 128 | { | ||
| 129 | Call oldHead = head; | ||
| 130 | head = newHead; | ||
| 131 | if (eNotificationRequired()) | ||
| 132 | { | ||
| 133 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD, oldHead, newHead); | ||
| 134 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 135 | } | ||
| 136 | return msgs; | ||
| 137 | } | ||
| 138 | |||
| 139 | /** | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @generated | ||
| 143 | */ | ||
| 144 | @Override | ||
| 145 | public void setHead(Call newHead) | ||
| 146 | { | ||
| 147 | if (newHead != head) | ||
| 148 | { | ||
| 149 | NotificationChain msgs = null; | ||
| 150 | if (head != null) | ||
| 151 | msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD, null, msgs); | ||
| 152 | if (newHead != null) | ||
| 153 | msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD, null, msgs); | ||
| 154 | msgs = basicSetHead(newHead, msgs); | ||
| 155 | if (msgs != null) msgs.dispatch(); | ||
| 156 | } | ||
| 157 | else if (eNotificationRequired()) | ||
| 158 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD, newHead, newHead)); | ||
| 159 | } | ||
| 160 | |||
| 161 | /** | ||
| 162 | * <!-- begin-user-doc --> | ||
| 163 | * <!-- end-user-doc --> | ||
| 164 | * @generated | ||
| 165 | */ | ||
| 166 | @Override | ||
| 167 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 168 | { | ||
| 169 | switch (featureID) | ||
| 170 | { | ||
| 171 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD: | ||
| 172 | return basicSetHead(null, msgs); | ||
| 173 | } | ||
| 174 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 175 | } | ||
| 176 | |||
| 177 | /** | ||
| 178 | * <!-- begin-user-doc --> | ||
| 179 | * <!-- end-user-doc --> | ||
| 180 | * @generated | ||
| 181 | */ | ||
| 182 | @Override | ||
| 183 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 184 | { | ||
| 185 | switch (featureID) | ||
| 186 | { | ||
| 187 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__TYPE: | ||
| 188 | return getType(); | ||
| 189 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD: | ||
| 190 | return getHead(); | ||
| 191 | } | ||
| 192 | return super.eGet(featureID, resolve, coreType); | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * <!-- begin-user-doc --> | ||
| 197 | * <!-- end-user-doc --> | ||
| 198 | * @generated | ||
| 199 | */ | ||
| 200 | @Override | ||
| 201 | public void eSet(int featureID, Object newValue) | ||
| 202 | { | ||
| 203 | switch (featureID) | ||
| 204 | { | ||
| 205 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__TYPE: | ||
| 206 | setType((MetricType)newValue); | ||
| 207 | return; | ||
| 208 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD: | ||
| 209 | setHead((Call)newValue); | ||
| 210 | return; | ||
| 211 | } | ||
| 212 | super.eSet(featureID, newValue); | ||
| 213 | } | ||
| 214 | |||
| 215 | /** | ||
| 216 | * <!-- begin-user-doc --> | ||
| 217 | * <!-- end-user-doc --> | ||
| 218 | * @generated | ||
| 219 | */ | ||
| 220 | @Override | ||
| 221 | public void eUnset(int featureID) | ||
| 222 | { | ||
| 223 | switch (featureID) | ||
| 224 | { | ||
| 225 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__TYPE: | ||
| 226 | setType(TYPE_EDEFAULT); | ||
| 227 | return; | ||
| 228 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD: | ||
| 229 | setHead((Call)null); | ||
| 230 | return; | ||
| 231 | } | ||
| 232 | super.eUnset(featureID); | ||
| 233 | } | ||
| 234 | |||
| 235 | /** | ||
| 236 | * <!-- begin-user-doc --> | ||
| 237 | * <!-- end-user-doc --> | ||
| 238 | * @generated | ||
| 239 | */ | ||
| 240 | @Override | ||
| 241 | public boolean eIsSet(int featureID) | ||
| 242 | { | ||
| 243 | switch (featureID) | ||
| 244 | { | ||
| 245 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__TYPE: | ||
| 246 | return type != TYPE_EDEFAULT; | ||
| 247 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION__HEAD: | ||
| 248 | return head != null; | ||
| 249 | } | ||
| 250 | return super.eIsSet(featureID); | ||
| 251 | } | ||
| 252 | |||
| 253 | /** | ||
| 254 | * <!-- begin-user-doc --> | ||
| 255 | * <!-- end-user-doc --> | ||
| 256 | * @generated | ||
| 257 | */ | ||
| 258 | @Override | ||
| 259 | public String toString() | ||
| 260 | { | ||
| 261 | if (eIsProxy()) return super.toString(); | ||
| 262 | |||
| 263 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 264 | result.append(" (type: "); | ||
| 265 | result.append(type); | ||
| 266 | result.append(')'); | ||
| 267 | return result.toString(); | ||
| 268 | } | ||
| 269 | |||
| 270 | } //ExternMetricDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExternPredicateDefinitionImpl.java index eb2835a0..0605cb0f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExternPredicateDefinitionImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -11,41 +11,41 @@ import org.eclipse.emf.ecore.InternalEObject; | |||
| 11 | 11 | ||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 13 | 13 | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.Call; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition; |
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 17 | 17 | ||
| 18 | /** | 18 | /** |
| 19 | * <!-- begin-user-doc --> | 19 | * <!-- begin-user-doc --> |
| 20 | * An implementation of the model object '<em><b>Default Interpretation</b></em>'. | 20 | * An implementation of the model object '<em><b>Extern Predicate Definition</b></em>'. |
| 21 | * <!-- end-user-doc --> | 21 | * <!-- end-user-doc --> |
| 22 | * <p> | 22 | * <p> |
| 23 | * The following features are implemented: | 23 | * The following features are implemented: |
| 24 | * </p> | 24 | * </p> |
| 25 | * <ul> | 25 | * <ul> |
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl#getInterpretation <em>Interpretation</em>}</li> | 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExternPredicateDefinitionImpl#getHead <em>Head</em>}</li> |
| 27 | * </ul> | 27 | * </ul> |
| 28 | * | 28 | * |
| 29 | * @generated | 29 | * @generated |
| 30 | */ | 30 | */ |
| 31 | public class DefaultInterpretationImpl extends InterpretationImpl implements DefaultInterpretation | 31 | public class ExternPredicateDefinitionImpl extends StatementImpl implements ExternPredicateDefinition |
| 32 | { | 32 | { |
| 33 | /** | 33 | /** |
| 34 | * The cached value of the '{@link #getInterpretation() <em>Interpretation</em>}' containment reference. | 34 | * The cached value of the '{@link #getHead() <em>Head</em>}' containment reference. |
| 35 | * <!-- begin-user-doc --> | 35 | * <!-- begin-user-doc --> |
| 36 | * <!-- end-user-doc --> | 36 | * <!-- end-user-doc --> |
| 37 | * @see #getInterpretation() | 37 | * @see #getHead() |
| 38 | * @generated | 38 | * @generated |
| 39 | * @ordered | 39 | * @ordered |
| 40 | */ | 40 | */ |
| 41 | protected BasicInterpretation interpretation; | 41 | protected Call head; |
| 42 | 42 | ||
| 43 | /** | 43 | /** |
| 44 | * <!-- begin-user-doc --> | 44 | * <!-- begin-user-doc --> |
| 45 | * <!-- end-user-doc --> | 45 | * <!-- end-user-doc --> |
| 46 | * @generated | 46 | * @generated |
| 47 | */ | 47 | */ |
| 48 | protected DefaultInterpretationImpl() | 48 | protected ExternPredicateDefinitionImpl() |
| 49 | { | 49 | { |
| 50 | super(); | 50 | super(); |
| 51 | } | 51 | } |
| @@ -58,7 +58,7 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 58 | @Override | 58 | @Override |
| 59 | protected EClass eStaticClass() | 59 | protected EClass eStaticClass() |
| 60 | { | 60 | { |
| 61 | return SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION; | 61 | return SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION; |
| 62 | } | 62 | } |
| 63 | 63 | ||
| 64 | /** | 64 | /** |
| @@ -67,9 +67,9 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 67 | * @generated | 67 | * @generated |
| 68 | */ | 68 | */ |
| 69 | @Override | 69 | @Override |
| 70 | public BasicInterpretation getInterpretation() | 70 | public Call getHead() |
| 71 | { | 71 | { |
| 72 | return interpretation; | 72 | return head; |
| 73 | } | 73 | } |
| 74 | 74 | ||
| 75 | /** | 75 | /** |
| @@ -77,13 +77,13 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 77 | * <!-- end-user-doc --> | 77 | * <!-- end-user-doc --> |
| 78 | * @generated | 78 | * @generated |
| 79 | */ | 79 | */ |
| 80 | public NotificationChain basicSetInterpretation(BasicInterpretation newInterpretation, NotificationChain msgs) | 80 | public NotificationChain basicSetHead(Call newHead, NotificationChain msgs) |
| 81 | { | 81 | { |
| 82 | BasicInterpretation oldInterpretation = interpretation; | 82 | Call oldHead = head; |
| 83 | interpretation = newInterpretation; | 83 | head = newHead; |
| 84 | if (eNotificationRequired()) | 84 | if (eNotificationRequired()) |
| 85 | { | 85 | { |
| 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, oldInterpretation, newInterpretation); | 86 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD, oldHead, newHead); |
| 87 | if (msgs == null) msgs = notification; else msgs.add(notification); | 87 | if (msgs == null) msgs = notification; else msgs.add(notification); |
| 88 | } | 88 | } |
| 89 | return msgs; | 89 | return msgs; |
| @@ -95,20 +95,20 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 95 | * @generated | 95 | * @generated |
| 96 | */ | 96 | */ |
| 97 | @Override | 97 | @Override |
| 98 | public void setInterpretation(BasicInterpretation newInterpretation) | 98 | public void setHead(Call newHead) |
| 99 | { | 99 | { |
| 100 | if (newInterpretation != interpretation) | 100 | if (newHead != head) |
| 101 | { | 101 | { |
| 102 | NotificationChain msgs = null; | 102 | NotificationChain msgs = null; |
| 103 | if (interpretation != null) | 103 | if (head != null) |
| 104 | msgs = ((InternalEObject)interpretation).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs); | 104 | msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD, null, msgs); |
| 105 | if (newInterpretation != null) | 105 | if (newHead != null) |
| 106 | msgs = ((InternalEObject)newInterpretation).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs); | 106 | msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD, null, msgs); |
| 107 | msgs = basicSetInterpretation(newInterpretation, msgs); | 107 | msgs = basicSetHead(newHead, msgs); |
| 108 | if (msgs != null) msgs.dispatch(); | 108 | if (msgs != null) msgs.dispatch(); |
| 109 | } | 109 | } |
| 110 | else if (eNotificationRequired()) | 110 | else if (eNotificationRequired()) |
| 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, newInterpretation, newInterpretation)); | 111 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD, newHead, newHead)); |
| 112 | } | 112 | } |
| 113 | 113 | ||
| 114 | /** | 114 | /** |
| @@ -121,8 +121,8 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 121 | { | 121 | { |
| 122 | switch (featureID) | 122 | switch (featureID) |
| 123 | { | 123 | { |
| 124 | case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: | 124 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD: |
| 125 | return basicSetInterpretation(null, msgs); | 125 | return basicSetHead(null, msgs); |
| 126 | } | 126 | } |
| 127 | return super.eInverseRemove(otherEnd, featureID, msgs); | 127 | return super.eInverseRemove(otherEnd, featureID, msgs); |
| 128 | } | 128 | } |
| @@ -137,8 +137,8 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 137 | { | 137 | { |
| 138 | switch (featureID) | 138 | switch (featureID) |
| 139 | { | 139 | { |
| 140 | case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: | 140 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD: |
| 141 | return getInterpretation(); | 141 | return getHead(); |
| 142 | } | 142 | } |
| 143 | return super.eGet(featureID, resolve, coreType); | 143 | return super.eGet(featureID, resolve, coreType); |
| 144 | } | 144 | } |
| @@ -153,8 +153,8 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 153 | { | 153 | { |
| 154 | switch (featureID) | 154 | switch (featureID) |
| 155 | { | 155 | { |
| 156 | case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: | 156 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD: |
| 157 | setInterpretation((BasicInterpretation)newValue); | 157 | setHead((Call)newValue); |
| 158 | return; | 158 | return; |
| 159 | } | 159 | } |
| 160 | super.eSet(featureID, newValue); | 160 | super.eSet(featureID, newValue); |
| @@ -170,8 +170,8 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 170 | { | 170 | { |
| 171 | switch (featureID) | 171 | switch (featureID) |
| 172 | { | 172 | { |
| 173 | case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: | 173 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD: |
| 174 | setInterpretation((BasicInterpretation)null); | 174 | setHead((Call)null); |
| 175 | return; | 175 | return; |
| 176 | } | 176 | } |
| 177 | super.eUnset(featureID); | 177 | super.eUnset(featureID); |
| @@ -187,10 +187,10 @@ public class DefaultInterpretationImpl extends InterpretationImpl implements Def | |||
| 187 | { | 187 | { |
| 188 | switch (featureID) | 188 | switch (featureID) |
| 189 | { | 189 | { |
| 190 | case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: | 190 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION__HEAD: |
| 191 | return interpretation != null; | 191 | return head != null; |
| 192 | } | 192 | } |
| 193 | return super.eIsSet(featureID); | 193 | return super.eIsSet(featureID); |
| 194 | } | 194 | } |
| 195 | 195 | ||
| 196 | } //DefaultInterpretationImpl | 196 | } //ExternPredicateDefinitionImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java deleted file mode 100644 index 332f9af3..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.False; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>False</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class FalseImpl extends TruthValueImpl implements False | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected FalseImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.FALSE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //FalseImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java deleted file mode 100644 index ea9b80b2..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java +++ /dev/null | |||
| @@ -1,418 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 14 | |||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 20 | |||
| 21 | /** | ||
| 22 | * <!-- begin-user-doc --> | ||
| 23 | * An implementation of the model object '<em><b>Field Relation Interpretation</b></em>'. | ||
| 24 | * <!-- end-user-doc --> | ||
| 25 | * <p> | ||
| 26 | * The following features are implemented: | ||
| 27 | * </p> | ||
| 28 | * <ul> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#isContainment <em>Containment</em>}</li> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getSymbol <em>Symbol</em>}</li> | ||
| 31 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 32 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getTarget <em>Target</em>}</li> | ||
| 33 | * </ul> | ||
| 34 | * | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | public class FieldRelationInterpretationImpl extends MinimalEObjectImpl.Container implements FieldRelationInterpretation | ||
| 38 | { | ||
| 39 | /** | ||
| 40 | * The default value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @see #isContainment() | ||
| 44 | * @generated | ||
| 45 | * @ordered | ||
| 46 | */ | ||
| 47 | protected static final boolean CONTAINMENT_EDEFAULT = false; | ||
| 48 | |||
| 49 | /** | ||
| 50 | * The cached value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @see #isContainment() | ||
| 54 | * @generated | ||
| 55 | * @ordered | ||
| 56 | */ | ||
| 57 | protected boolean containment = CONTAINMENT_EDEFAULT; | ||
| 58 | |||
| 59 | /** | ||
| 60 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @see #getSymbol() | ||
| 64 | * @generated | ||
| 65 | * @ordered | ||
| 66 | */ | ||
| 67 | protected ModelSymbol symbol; | ||
| 68 | |||
| 69 | /** | ||
| 70 | * The cached value of the '{@link #getMultiplicity() <em>Multiplicity</em>}' containment reference. | ||
| 71 | * <!-- begin-user-doc --> | ||
| 72 | * <!-- end-user-doc --> | ||
| 73 | * @see #getMultiplicity() | ||
| 74 | * @generated | ||
| 75 | * @ordered | ||
| 76 | */ | ||
| 77 | protected MultiplicityDefinition multiplicity; | ||
| 78 | |||
| 79 | /** | ||
| 80 | * The cached value of the '{@link #getTarget() <em>Target</em>}' containment reference. | ||
| 81 | * <!-- begin-user-doc --> | ||
| 82 | * <!-- end-user-doc --> | ||
| 83 | * @see #getTarget() | ||
| 84 | * @generated | ||
| 85 | * @ordered | ||
| 86 | */ | ||
| 87 | protected Symbol target; | ||
| 88 | |||
| 89 | /** | ||
| 90 | * <!-- begin-user-doc --> | ||
| 91 | * <!-- end-user-doc --> | ||
| 92 | * @generated | ||
| 93 | */ | ||
| 94 | protected FieldRelationInterpretationImpl() | ||
| 95 | { | ||
| 96 | super(); | ||
| 97 | } | ||
| 98 | |||
| 99 | /** | ||
| 100 | * <!-- begin-user-doc --> | ||
| 101 | * <!-- end-user-doc --> | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | @Override | ||
| 105 | protected EClass eStaticClass() | ||
| 106 | { | ||
| 107 | return SolverLanguagePackage.Literals.FIELD_RELATION_INTERPRETATION; | ||
| 108 | } | ||
| 109 | |||
| 110 | /** | ||
| 111 | * <!-- begin-user-doc --> | ||
| 112 | * <!-- end-user-doc --> | ||
| 113 | * @generated | ||
| 114 | */ | ||
| 115 | @Override | ||
| 116 | public boolean isContainment() | ||
| 117 | { | ||
| 118 | return containment; | ||
| 119 | } | ||
| 120 | |||
| 121 | /** | ||
| 122 | * <!-- begin-user-doc --> | ||
| 123 | * <!-- end-user-doc --> | ||
| 124 | * @generated | ||
| 125 | */ | ||
| 126 | @Override | ||
| 127 | public void setContainment(boolean newContainment) | ||
| 128 | { | ||
| 129 | boolean oldContainment = containment; | ||
| 130 | containment = newContainment; | ||
| 131 | if (eNotificationRequired()) | ||
| 132 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment)); | ||
| 133 | } | ||
| 134 | |||
| 135 | /** | ||
| 136 | * <!-- begin-user-doc --> | ||
| 137 | * <!-- end-user-doc --> | ||
| 138 | * @generated | ||
| 139 | */ | ||
| 140 | @Override | ||
| 141 | public ModelSymbol getSymbol() | ||
| 142 | { | ||
| 143 | return symbol; | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 152 | { | ||
| 153 | ModelSymbol oldSymbol = symbol; | ||
| 154 | symbol = newSymbol; | ||
| 155 | if (eNotificationRequired()) | ||
| 156 | { | ||
| 157 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); | ||
| 158 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 159 | } | ||
| 160 | return msgs; | ||
| 161 | } | ||
| 162 | |||
| 163 | /** | ||
| 164 | * <!-- begin-user-doc --> | ||
| 165 | * <!-- end-user-doc --> | ||
| 166 | * @generated | ||
| 167 | */ | ||
| 168 | @Override | ||
| 169 | public void setSymbol(ModelSymbol newSymbol) | ||
| 170 | { | ||
| 171 | if (newSymbol != symbol) | ||
| 172 | { | ||
| 173 | NotificationChain msgs = null; | ||
| 174 | if (symbol != null) | ||
| 175 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs); | ||
| 176 | if (newSymbol != null) | ||
| 177 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs); | ||
| 178 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 179 | if (msgs != null) msgs.dispatch(); | ||
| 180 | } | ||
| 181 | else if (eNotificationRequired()) | ||
| 182 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); | ||
| 183 | } | ||
| 184 | |||
| 185 | /** | ||
| 186 | * <!-- begin-user-doc --> | ||
| 187 | * <!-- end-user-doc --> | ||
| 188 | * @generated | ||
| 189 | */ | ||
| 190 | @Override | ||
| 191 | public MultiplicityDefinition getMultiplicity() | ||
| 192 | { | ||
| 193 | return multiplicity; | ||
| 194 | } | ||
| 195 | |||
| 196 | /** | ||
| 197 | * <!-- begin-user-doc --> | ||
| 198 | * <!-- end-user-doc --> | ||
| 199 | * @generated | ||
| 200 | */ | ||
| 201 | public NotificationChain basicSetMultiplicity(MultiplicityDefinition newMultiplicity, NotificationChain msgs) | ||
| 202 | { | ||
| 203 | MultiplicityDefinition oldMultiplicity = multiplicity; | ||
| 204 | multiplicity = newMultiplicity; | ||
| 205 | if (eNotificationRequired()) | ||
| 206 | { | ||
| 207 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, oldMultiplicity, newMultiplicity); | ||
| 208 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 209 | } | ||
| 210 | return msgs; | ||
| 211 | } | ||
| 212 | |||
| 213 | /** | ||
| 214 | * <!-- begin-user-doc --> | ||
| 215 | * <!-- end-user-doc --> | ||
| 216 | * @generated | ||
| 217 | */ | ||
| 218 | @Override | ||
| 219 | public void setMultiplicity(MultiplicityDefinition newMultiplicity) | ||
| 220 | { | ||
| 221 | if (newMultiplicity != multiplicity) | ||
| 222 | { | ||
| 223 | NotificationChain msgs = null; | ||
| 224 | if (multiplicity != null) | ||
| 225 | msgs = ((InternalEObject)multiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs); | ||
| 226 | if (newMultiplicity != null) | ||
| 227 | msgs = ((InternalEObject)newMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs); | ||
| 228 | msgs = basicSetMultiplicity(newMultiplicity, msgs); | ||
| 229 | if (msgs != null) msgs.dispatch(); | ||
| 230 | } | ||
| 231 | else if (eNotificationRequired()) | ||
| 232 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, newMultiplicity, newMultiplicity)); | ||
| 233 | } | ||
| 234 | |||
| 235 | /** | ||
| 236 | * <!-- begin-user-doc --> | ||
| 237 | * <!-- end-user-doc --> | ||
| 238 | * @generated | ||
| 239 | */ | ||
| 240 | @Override | ||
| 241 | public Symbol getTarget() | ||
| 242 | { | ||
| 243 | return target; | ||
| 244 | } | ||
| 245 | |||
| 246 | /** | ||
| 247 | * <!-- begin-user-doc --> | ||
| 248 | * <!-- end-user-doc --> | ||
| 249 | * @generated | ||
| 250 | */ | ||
| 251 | public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs) | ||
| 252 | { | ||
| 253 | Symbol oldTarget = target; | ||
| 254 | target = newTarget; | ||
| 255 | if (eNotificationRequired()) | ||
| 256 | { | ||
| 257 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget); | ||
| 258 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 259 | } | ||
| 260 | return msgs; | ||
| 261 | } | ||
| 262 | |||
| 263 | /** | ||
| 264 | * <!-- begin-user-doc --> | ||
| 265 | * <!-- end-user-doc --> | ||
| 266 | * @generated | ||
| 267 | */ | ||
| 268 | @Override | ||
| 269 | public void setTarget(Symbol newTarget) | ||
| 270 | { | ||
| 271 | if (newTarget != target) | ||
| 272 | { | ||
| 273 | NotificationChain msgs = null; | ||
| 274 | if (target != null) | ||
| 275 | msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs); | ||
| 276 | if (newTarget != null) | ||
| 277 | msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs); | ||
| 278 | msgs = basicSetTarget(newTarget, msgs); | ||
| 279 | if (msgs != null) msgs.dispatch(); | ||
| 280 | } | ||
| 281 | else if (eNotificationRequired()) | ||
| 282 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, newTarget, newTarget)); | ||
| 283 | } | ||
| 284 | |||
| 285 | /** | ||
| 286 | * <!-- begin-user-doc --> | ||
| 287 | * <!-- end-user-doc --> | ||
| 288 | * @generated | ||
| 289 | */ | ||
| 290 | @Override | ||
| 291 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 292 | { | ||
| 293 | switch (featureID) | ||
| 294 | { | ||
| 295 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: | ||
| 296 | return basicSetSymbol(null, msgs); | ||
| 297 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: | ||
| 298 | return basicSetMultiplicity(null, msgs); | ||
| 299 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: | ||
| 300 | return basicSetTarget(null, msgs); | ||
| 301 | } | ||
| 302 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 303 | } | ||
| 304 | |||
| 305 | /** | ||
| 306 | * <!-- begin-user-doc --> | ||
| 307 | * <!-- end-user-doc --> | ||
| 308 | * @generated | ||
| 309 | */ | ||
| 310 | @Override | ||
| 311 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 312 | { | ||
| 313 | switch (featureID) | ||
| 314 | { | ||
| 315 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 316 | return isContainment(); | ||
| 317 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: | ||
| 318 | return getSymbol(); | ||
| 319 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: | ||
| 320 | return getMultiplicity(); | ||
| 321 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: | ||
| 322 | return getTarget(); | ||
| 323 | } | ||
| 324 | return super.eGet(featureID, resolve, coreType); | ||
| 325 | } | ||
| 326 | |||
| 327 | /** | ||
| 328 | * <!-- begin-user-doc --> | ||
| 329 | * <!-- end-user-doc --> | ||
| 330 | * @generated | ||
| 331 | */ | ||
| 332 | @Override | ||
| 333 | public void eSet(int featureID, Object newValue) | ||
| 334 | { | ||
| 335 | switch (featureID) | ||
| 336 | { | ||
| 337 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 338 | setContainment((Boolean)newValue); | ||
| 339 | return; | ||
| 340 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: | ||
| 341 | setSymbol((ModelSymbol)newValue); | ||
| 342 | return; | ||
| 343 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: | ||
| 344 | setMultiplicity((MultiplicityDefinition)newValue); | ||
| 345 | return; | ||
| 346 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: | ||
| 347 | setTarget((Symbol)newValue); | ||
| 348 | return; | ||
| 349 | } | ||
| 350 | super.eSet(featureID, newValue); | ||
| 351 | } | ||
| 352 | |||
| 353 | /** | ||
| 354 | * <!-- begin-user-doc --> | ||
| 355 | * <!-- end-user-doc --> | ||
| 356 | * @generated | ||
| 357 | */ | ||
| 358 | @Override | ||
| 359 | public void eUnset(int featureID) | ||
| 360 | { | ||
| 361 | switch (featureID) | ||
| 362 | { | ||
| 363 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 364 | setContainment(CONTAINMENT_EDEFAULT); | ||
| 365 | return; | ||
| 366 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: | ||
| 367 | setSymbol((ModelSymbol)null); | ||
| 368 | return; | ||
| 369 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: | ||
| 370 | setMultiplicity((MultiplicityDefinition)null); | ||
| 371 | return; | ||
| 372 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: | ||
| 373 | setTarget((Symbol)null); | ||
| 374 | return; | ||
| 375 | } | ||
| 376 | super.eUnset(featureID); | ||
| 377 | } | ||
| 378 | |||
| 379 | /** | ||
| 380 | * <!-- begin-user-doc --> | ||
| 381 | * <!-- end-user-doc --> | ||
| 382 | * @generated | ||
| 383 | */ | ||
| 384 | @Override | ||
| 385 | public boolean eIsSet(int featureID) | ||
| 386 | { | ||
| 387 | switch (featureID) | ||
| 388 | { | ||
| 389 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 390 | return containment != CONTAINMENT_EDEFAULT; | ||
| 391 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: | ||
| 392 | return symbol != null; | ||
| 393 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: | ||
| 394 | return multiplicity != null; | ||
| 395 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: | ||
| 396 | return target != null; | ||
| 397 | } | ||
| 398 | return super.eIsSet(featureID); | ||
| 399 | } | ||
| 400 | |||
| 401 | /** | ||
| 402 | * <!-- begin-user-doc --> | ||
| 403 | * <!-- end-user-doc --> | ||
| 404 | * @generated | ||
| 405 | */ | ||
| 406 | @Override | ||
| 407 | public String toString() | ||
| 408 | { | ||
| 409 | if (eIsProxy()) return super.toString(); | ||
| 410 | |||
| 411 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 412 | result.append(" (containment: "); | ||
| 413 | result.append(containment); | ||
| 414 | result.append(')'); | ||
| 415 | return result.toString(); | ||
| 416 | } | ||
| 417 | |||
| 418 | } //FieldRelationInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java deleted file mode 100644 index 52f7a67d..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java +++ /dev/null | |||
| @@ -1,563 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 19 | |||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * An implementation of the model object '<em><b>Global Relation Interpretation</b></em>'. | ||
| 23 | * <!-- end-user-doc --> | ||
| 24 | * <p> | ||
| 25 | * The following features are implemented: | ||
| 26 | * </p> | ||
| 27 | * <ul> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#isContainment <em>Containment</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSymbol <em>Symbol</em>}</li> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSourceMultiplicity <em>Source Multiplicity</em>}</li> | ||
| 31 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSource <em>Source</em>}</li> | ||
| 32 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTargetMultiplicity <em>Target Multiplicity</em>}</li> | ||
| 33 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTarget <em>Target</em>}</li> | ||
| 34 | * </ul> | ||
| 35 | * | ||
| 36 | * @generated | ||
| 37 | */ | ||
| 38 | public class GlobalRelationInterpretationImpl extends CDInterpretationImpl implements GlobalRelationInterpretation | ||
| 39 | { | ||
| 40 | /** | ||
| 41 | * The default value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @see #isContainment() | ||
| 45 | * @generated | ||
| 46 | * @ordered | ||
| 47 | */ | ||
| 48 | protected static final boolean CONTAINMENT_EDEFAULT = false; | ||
| 49 | |||
| 50 | /** | ||
| 51 | * The cached value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 52 | * <!-- begin-user-doc --> | ||
| 53 | * <!-- end-user-doc --> | ||
| 54 | * @see #isContainment() | ||
| 55 | * @generated | ||
| 56 | * @ordered | ||
| 57 | */ | ||
| 58 | protected boolean containment = CONTAINMENT_EDEFAULT; | ||
| 59 | |||
| 60 | /** | ||
| 61 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 62 | * <!-- begin-user-doc --> | ||
| 63 | * <!-- end-user-doc --> | ||
| 64 | * @see #getSymbol() | ||
| 65 | * @generated | ||
| 66 | * @ordered | ||
| 67 | */ | ||
| 68 | protected ModelSymbol symbol; | ||
| 69 | |||
| 70 | /** | ||
| 71 | * The cached value of the '{@link #getSourceMultiplicity() <em>Source Multiplicity</em>}' containment reference. | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @see #getSourceMultiplicity() | ||
| 75 | * @generated | ||
| 76 | * @ordered | ||
| 77 | */ | ||
| 78 | protected MultiplicityDefinition sourceMultiplicity; | ||
| 79 | |||
| 80 | /** | ||
| 81 | * The cached value of the '{@link #getSource() <em>Source</em>}' containment reference. | ||
| 82 | * <!-- begin-user-doc --> | ||
| 83 | * <!-- end-user-doc --> | ||
| 84 | * @see #getSource() | ||
| 85 | * @generated | ||
| 86 | * @ordered | ||
| 87 | */ | ||
| 88 | protected Symbol source; | ||
| 89 | |||
| 90 | /** | ||
| 91 | * The cached value of the '{@link #getTargetMultiplicity() <em>Target Multiplicity</em>}' containment reference. | ||
| 92 | * <!-- begin-user-doc --> | ||
| 93 | * <!-- end-user-doc --> | ||
| 94 | * @see #getTargetMultiplicity() | ||
| 95 | * @generated | ||
| 96 | * @ordered | ||
| 97 | */ | ||
| 98 | protected MultiplicityDefinition targetMultiplicity; | ||
| 99 | |||
| 100 | /** | ||
| 101 | * The cached value of the '{@link #getTarget() <em>Target</em>}' containment reference. | ||
| 102 | * <!-- begin-user-doc --> | ||
| 103 | * <!-- end-user-doc --> | ||
| 104 | * @see #getTarget() | ||
| 105 | * @generated | ||
| 106 | * @ordered | ||
| 107 | */ | ||
| 108 | protected Symbol target; | ||
| 109 | |||
| 110 | /** | ||
| 111 | * <!-- begin-user-doc --> | ||
| 112 | * <!-- end-user-doc --> | ||
| 113 | * @generated | ||
| 114 | */ | ||
| 115 | protected GlobalRelationInterpretationImpl() | ||
| 116 | { | ||
| 117 | super(); | ||
| 118 | } | ||
| 119 | |||
| 120 | /** | ||
| 121 | * <!-- begin-user-doc --> | ||
| 122 | * <!-- end-user-doc --> | ||
| 123 | * @generated | ||
| 124 | */ | ||
| 125 | @Override | ||
| 126 | protected EClass eStaticClass() | ||
| 127 | { | ||
| 128 | return SolverLanguagePackage.Literals.GLOBAL_RELATION_INTERPRETATION; | ||
| 129 | } | ||
| 130 | |||
| 131 | /** | ||
| 132 | * <!-- begin-user-doc --> | ||
| 133 | * <!-- end-user-doc --> | ||
| 134 | * @generated | ||
| 135 | */ | ||
| 136 | @Override | ||
| 137 | public boolean isContainment() | ||
| 138 | { | ||
| 139 | return containment; | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public void setContainment(boolean newContainment) | ||
| 149 | { | ||
| 150 | boolean oldContainment = containment; | ||
| 151 | containment = newContainment; | ||
| 152 | if (eNotificationRequired()) | ||
| 153 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment)); | ||
| 154 | } | ||
| 155 | |||
| 156 | /** | ||
| 157 | * <!-- begin-user-doc --> | ||
| 158 | * <!-- end-user-doc --> | ||
| 159 | * @generated | ||
| 160 | */ | ||
| 161 | @Override | ||
| 162 | public ModelSymbol getSymbol() | ||
| 163 | { | ||
| 164 | return symbol; | ||
| 165 | } | ||
| 166 | |||
| 167 | /** | ||
| 168 | * <!-- begin-user-doc --> | ||
| 169 | * <!-- end-user-doc --> | ||
| 170 | * @generated | ||
| 171 | */ | ||
| 172 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 173 | { | ||
| 174 | ModelSymbol oldSymbol = symbol; | ||
| 175 | symbol = newSymbol; | ||
| 176 | if (eNotificationRequired()) | ||
| 177 | { | ||
| 178 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); | ||
| 179 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 180 | } | ||
| 181 | return msgs; | ||
| 182 | } | ||
| 183 | |||
| 184 | /** | ||
| 185 | * <!-- begin-user-doc --> | ||
| 186 | * <!-- end-user-doc --> | ||
| 187 | * @generated | ||
| 188 | */ | ||
| 189 | @Override | ||
| 190 | public void setSymbol(ModelSymbol newSymbol) | ||
| 191 | { | ||
| 192 | if (newSymbol != symbol) | ||
| 193 | { | ||
| 194 | NotificationChain msgs = null; | ||
| 195 | if (symbol != null) | ||
| 196 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs); | ||
| 197 | if (newSymbol != null) | ||
| 198 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs); | ||
| 199 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 200 | if (msgs != null) msgs.dispatch(); | ||
| 201 | } | ||
| 202 | else if (eNotificationRequired()) | ||
| 203 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); | ||
| 204 | } | ||
| 205 | |||
| 206 | /** | ||
| 207 | * <!-- begin-user-doc --> | ||
| 208 | * <!-- end-user-doc --> | ||
| 209 | * @generated | ||
| 210 | */ | ||
| 211 | @Override | ||
| 212 | public MultiplicityDefinition getSourceMultiplicity() | ||
| 213 | { | ||
| 214 | return sourceMultiplicity; | ||
| 215 | } | ||
| 216 | |||
| 217 | /** | ||
| 218 | * <!-- begin-user-doc --> | ||
| 219 | * <!-- end-user-doc --> | ||
| 220 | * @generated | ||
| 221 | */ | ||
| 222 | public NotificationChain basicSetSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity, NotificationChain msgs) | ||
| 223 | { | ||
| 224 | MultiplicityDefinition oldSourceMultiplicity = sourceMultiplicity; | ||
| 225 | sourceMultiplicity = newSourceMultiplicity; | ||
| 226 | if (eNotificationRequired()) | ||
| 227 | { | ||
| 228 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, oldSourceMultiplicity, newSourceMultiplicity); | ||
| 229 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 230 | } | ||
| 231 | return msgs; | ||
| 232 | } | ||
| 233 | |||
| 234 | /** | ||
| 235 | * <!-- begin-user-doc --> | ||
| 236 | * <!-- end-user-doc --> | ||
| 237 | * @generated | ||
| 238 | */ | ||
| 239 | @Override | ||
| 240 | public void setSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity) | ||
| 241 | { | ||
| 242 | if (newSourceMultiplicity != sourceMultiplicity) | ||
| 243 | { | ||
| 244 | NotificationChain msgs = null; | ||
| 245 | if (sourceMultiplicity != null) | ||
| 246 | msgs = ((InternalEObject)sourceMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs); | ||
| 247 | if (newSourceMultiplicity != null) | ||
| 248 | msgs = ((InternalEObject)newSourceMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs); | ||
| 249 | msgs = basicSetSourceMultiplicity(newSourceMultiplicity, msgs); | ||
| 250 | if (msgs != null) msgs.dispatch(); | ||
| 251 | } | ||
| 252 | else if (eNotificationRequired()) | ||
| 253 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, newSourceMultiplicity, newSourceMultiplicity)); | ||
| 254 | } | ||
| 255 | |||
| 256 | /** | ||
| 257 | * <!-- begin-user-doc --> | ||
| 258 | * <!-- end-user-doc --> | ||
| 259 | * @generated | ||
| 260 | */ | ||
| 261 | @Override | ||
| 262 | public Symbol getSource() | ||
| 263 | { | ||
| 264 | return source; | ||
| 265 | } | ||
| 266 | |||
| 267 | /** | ||
| 268 | * <!-- begin-user-doc --> | ||
| 269 | * <!-- end-user-doc --> | ||
| 270 | * @generated | ||
| 271 | */ | ||
| 272 | public NotificationChain basicSetSource(Symbol newSource, NotificationChain msgs) | ||
| 273 | { | ||
| 274 | Symbol oldSource = source; | ||
| 275 | source = newSource; | ||
| 276 | if (eNotificationRequired()) | ||
| 277 | { | ||
| 278 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, oldSource, newSource); | ||
| 279 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 280 | } | ||
| 281 | return msgs; | ||
| 282 | } | ||
| 283 | |||
| 284 | /** | ||
| 285 | * <!-- begin-user-doc --> | ||
| 286 | * <!-- end-user-doc --> | ||
| 287 | * @generated | ||
| 288 | */ | ||
| 289 | @Override | ||
| 290 | public void setSource(Symbol newSource) | ||
| 291 | { | ||
| 292 | if (newSource != source) | ||
| 293 | { | ||
| 294 | NotificationChain msgs = null; | ||
| 295 | if (source != null) | ||
| 296 | msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs); | ||
| 297 | if (newSource != null) | ||
| 298 | msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs); | ||
| 299 | msgs = basicSetSource(newSource, msgs); | ||
| 300 | if (msgs != null) msgs.dispatch(); | ||
| 301 | } | ||
| 302 | else if (eNotificationRequired()) | ||
| 303 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, newSource, newSource)); | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public MultiplicityDefinition getTargetMultiplicity() | ||
| 313 | { | ||
| 314 | return targetMultiplicity; | ||
| 315 | } | ||
| 316 | |||
| 317 | /** | ||
| 318 | * <!-- begin-user-doc --> | ||
| 319 | * <!-- end-user-doc --> | ||
| 320 | * @generated | ||
| 321 | */ | ||
| 322 | public NotificationChain basicSetTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity, NotificationChain msgs) | ||
| 323 | { | ||
| 324 | MultiplicityDefinition oldTargetMultiplicity = targetMultiplicity; | ||
| 325 | targetMultiplicity = newTargetMultiplicity; | ||
| 326 | if (eNotificationRequired()) | ||
| 327 | { | ||
| 328 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, oldTargetMultiplicity, newTargetMultiplicity); | ||
| 329 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 330 | } | ||
| 331 | return msgs; | ||
| 332 | } | ||
| 333 | |||
| 334 | /** | ||
| 335 | * <!-- begin-user-doc --> | ||
| 336 | * <!-- end-user-doc --> | ||
| 337 | * @generated | ||
| 338 | */ | ||
| 339 | @Override | ||
| 340 | public void setTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity) | ||
| 341 | { | ||
| 342 | if (newTargetMultiplicity != targetMultiplicity) | ||
| 343 | { | ||
| 344 | NotificationChain msgs = null; | ||
| 345 | if (targetMultiplicity != null) | ||
| 346 | msgs = ((InternalEObject)targetMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs); | ||
| 347 | if (newTargetMultiplicity != null) | ||
| 348 | msgs = ((InternalEObject)newTargetMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs); | ||
| 349 | msgs = basicSetTargetMultiplicity(newTargetMultiplicity, msgs); | ||
| 350 | if (msgs != null) msgs.dispatch(); | ||
| 351 | } | ||
| 352 | else if (eNotificationRequired()) | ||
| 353 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, newTargetMultiplicity, newTargetMultiplicity)); | ||
| 354 | } | ||
| 355 | |||
| 356 | /** | ||
| 357 | * <!-- begin-user-doc --> | ||
| 358 | * <!-- end-user-doc --> | ||
| 359 | * @generated | ||
| 360 | */ | ||
| 361 | @Override | ||
| 362 | public Symbol getTarget() | ||
| 363 | { | ||
| 364 | return target; | ||
| 365 | } | ||
| 366 | |||
| 367 | /** | ||
| 368 | * <!-- begin-user-doc --> | ||
| 369 | * <!-- end-user-doc --> | ||
| 370 | * @generated | ||
| 371 | */ | ||
| 372 | public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs) | ||
| 373 | { | ||
| 374 | Symbol oldTarget = target; | ||
| 375 | target = newTarget; | ||
| 376 | if (eNotificationRequired()) | ||
| 377 | { | ||
| 378 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget); | ||
| 379 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 380 | } | ||
| 381 | return msgs; | ||
| 382 | } | ||
| 383 | |||
| 384 | /** | ||
| 385 | * <!-- begin-user-doc --> | ||
| 386 | * <!-- end-user-doc --> | ||
| 387 | * @generated | ||
| 388 | */ | ||
| 389 | @Override | ||
| 390 | public void setTarget(Symbol newTarget) | ||
| 391 | { | ||
| 392 | if (newTarget != target) | ||
| 393 | { | ||
| 394 | NotificationChain msgs = null; | ||
| 395 | if (target != null) | ||
| 396 | msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs); | ||
| 397 | if (newTarget != null) | ||
| 398 | msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs); | ||
| 399 | msgs = basicSetTarget(newTarget, msgs); | ||
| 400 | if (msgs != null) msgs.dispatch(); | ||
| 401 | } | ||
| 402 | else if (eNotificationRequired()) | ||
| 403 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, newTarget, newTarget)); | ||
| 404 | } | ||
| 405 | |||
| 406 | /** | ||
| 407 | * <!-- begin-user-doc --> | ||
| 408 | * <!-- end-user-doc --> | ||
| 409 | * @generated | ||
| 410 | */ | ||
| 411 | @Override | ||
| 412 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 413 | { | ||
| 414 | switch (featureID) | ||
| 415 | { | ||
| 416 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: | ||
| 417 | return basicSetSymbol(null, msgs); | ||
| 418 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: | ||
| 419 | return basicSetSourceMultiplicity(null, msgs); | ||
| 420 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: | ||
| 421 | return basicSetSource(null, msgs); | ||
| 422 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: | ||
| 423 | return basicSetTargetMultiplicity(null, msgs); | ||
| 424 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: | ||
| 425 | return basicSetTarget(null, msgs); | ||
| 426 | } | ||
| 427 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 428 | } | ||
| 429 | |||
| 430 | /** | ||
| 431 | * <!-- begin-user-doc --> | ||
| 432 | * <!-- end-user-doc --> | ||
| 433 | * @generated | ||
| 434 | */ | ||
| 435 | @Override | ||
| 436 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 437 | { | ||
| 438 | switch (featureID) | ||
| 439 | { | ||
| 440 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 441 | return isContainment(); | ||
| 442 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: | ||
| 443 | return getSymbol(); | ||
| 444 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: | ||
| 445 | return getSourceMultiplicity(); | ||
| 446 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: | ||
| 447 | return getSource(); | ||
| 448 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: | ||
| 449 | return getTargetMultiplicity(); | ||
| 450 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: | ||
| 451 | return getTarget(); | ||
| 452 | } | ||
| 453 | return super.eGet(featureID, resolve, coreType); | ||
| 454 | } | ||
| 455 | |||
| 456 | /** | ||
| 457 | * <!-- begin-user-doc --> | ||
| 458 | * <!-- end-user-doc --> | ||
| 459 | * @generated | ||
| 460 | */ | ||
| 461 | @Override | ||
| 462 | public void eSet(int featureID, Object newValue) | ||
| 463 | { | ||
| 464 | switch (featureID) | ||
| 465 | { | ||
| 466 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 467 | setContainment((Boolean)newValue); | ||
| 468 | return; | ||
| 469 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: | ||
| 470 | setSymbol((ModelSymbol)newValue); | ||
| 471 | return; | ||
| 472 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: | ||
| 473 | setSourceMultiplicity((MultiplicityDefinition)newValue); | ||
| 474 | return; | ||
| 475 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: | ||
| 476 | setSource((Symbol)newValue); | ||
| 477 | return; | ||
| 478 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: | ||
| 479 | setTargetMultiplicity((MultiplicityDefinition)newValue); | ||
| 480 | return; | ||
| 481 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: | ||
| 482 | setTarget((Symbol)newValue); | ||
| 483 | return; | ||
| 484 | } | ||
| 485 | super.eSet(featureID, newValue); | ||
| 486 | } | ||
| 487 | |||
| 488 | /** | ||
| 489 | * <!-- begin-user-doc --> | ||
| 490 | * <!-- end-user-doc --> | ||
| 491 | * @generated | ||
| 492 | */ | ||
| 493 | @Override | ||
| 494 | public void eUnset(int featureID) | ||
| 495 | { | ||
| 496 | switch (featureID) | ||
| 497 | { | ||
| 498 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 499 | setContainment(CONTAINMENT_EDEFAULT); | ||
| 500 | return; | ||
| 501 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: | ||
| 502 | setSymbol((ModelSymbol)null); | ||
| 503 | return; | ||
| 504 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: | ||
| 505 | setSourceMultiplicity((MultiplicityDefinition)null); | ||
| 506 | return; | ||
| 507 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: | ||
| 508 | setSource((Symbol)null); | ||
| 509 | return; | ||
| 510 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: | ||
| 511 | setTargetMultiplicity((MultiplicityDefinition)null); | ||
| 512 | return; | ||
| 513 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: | ||
| 514 | setTarget((Symbol)null); | ||
| 515 | return; | ||
| 516 | } | ||
| 517 | super.eUnset(featureID); | ||
| 518 | } | ||
| 519 | |||
| 520 | /** | ||
| 521 | * <!-- begin-user-doc --> | ||
| 522 | * <!-- end-user-doc --> | ||
| 523 | * @generated | ||
| 524 | */ | ||
| 525 | @Override | ||
| 526 | public boolean eIsSet(int featureID) | ||
| 527 | { | ||
| 528 | switch (featureID) | ||
| 529 | { | ||
| 530 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: | ||
| 531 | return containment != CONTAINMENT_EDEFAULT; | ||
| 532 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: | ||
| 533 | return symbol != null; | ||
| 534 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: | ||
| 535 | return sourceMultiplicity != null; | ||
| 536 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: | ||
| 537 | return source != null; | ||
| 538 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: | ||
| 539 | return targetMultiplicity != null; | ||
| 540 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: | ||
| 541 | return target != null; | ||
| 542 | } | ||
| 543 | return super.eIsSet(featureID); | ||
| 544 | } | ||
| 545 | |||
| 546 | /** | ||
| 547 | * <!-- begin-user-doc --> | ||
| 548 | * <!-- end-user-doc --> | ||
| 549 | * @generated | ||
| 550 | */ | ||
| 551 | @Override | ||
| 552 | public String toString() | ||
| 553 | { | ||
| 554 | if (eIsProxy()) return super.toString(); | ||
| 555 | |||
| 556 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 557 | result.append(" (containment: "); | ||
| 558 | result.append(containment); | ||
| 559 | result.append(')'); | ||
| 560 | return result.toString(); | ||
| 561 | } | ||
| 562 | |||
| 563 | } //GlobalRelationInterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IfElseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IfElseImpl.java new file mode 100644 index 00000000..1b873568 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IfElseImpl.java | |||
| @@ -0,0 +1,342 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.IfElse; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 17 | |||
| 18 | /** | ||
| 19 | * <!-- begin-user-doc --> | ||
| 20 | * An implementation of the model object '<em><b>If Else</b></em>'. | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * <p> | ||
| 23 | * The following features are implemented: | ||
| 24 | * </p> | ||
| 25 | * <ul> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl#getCondition <em>Condition</em>}</li> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl#getThen <em>Then</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IfElseImpl#getElse <em>Else</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class IfElseImpl extends ExpressionImpl implements IfElse | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The cached value of the '{@link #getCondition() <em>Condition</em>}' containment reference. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getCondition() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected Expression condition; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getThen() <em>Then</em>}' containment reference. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getThen() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected Expression then; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #getElse() <em>Else</em>}' containment reference. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #getElse() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected Expression else_; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | protected IfElseImpl() | ||
| 71 | { | ||
| 72 | super(); | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | protected EClass eStaticClass() | ||
| 82 | { | ||
| 83 | return SolverLanguagePackage.Literals.IF_ELSE; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | public Expression getCondition() | ||
| 93 | { | ||
| 94 | return condition; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs) | ||
| 103 | { | ||
| 104 | Expression oldCondition = condition; | ||
| 105 | condition = newCondition; | ||
| 106 | if (eNotificationRequired()) | ||
| 107 | { | ||
| 108 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__CONDITION, oldCondition, newCondition); | ||
| 109 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 110 | } | ||
| 111 | return msgs; | ||
| 112 | } | ||
| 113 | |||
| 114 | /** | ||
| 115 | * <!-- begin-user-doc --> | ||
| 116 | * <!-- end-user-doc --> | ||
| 117 | * @generated | ||
| 118 | */ | ||
| 119 | @Override | ||
| 120 | public void setCondition(Expression newCondition) | ||
| 121 | { | ||
| 122 | if (newCondition != condition) | ||
| 123 | { | ||
| 124 | NotificationChain msgs = null; | ||
| 125 | if (condition != null) | ||
| 126 | msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__CONDITION, null, msgs); | ||
| 127 | if (newCondition != null) | ||
| 128 | msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__CONDITION, null, msgs); | ||
| 129 | msgs = basicSetCondition(newCondition, msgs); | ||
| 130 | if (msgs != null) msgs.dispatch(); | ||
| 131 | } | ||
| 132 | else if (eNotificationRequired()) | ||
| 133 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__CONDITION, newCondition, newCondition)); | ||
| 134 | } | ||
| 135 | |||
| 136 | /** | ||
| 137 | * <!-- begin-user-doc --> | ||
| 138 | * <!-- end-user-doc --> | ||
| 139 | * @generated | ||
| 140 | */ | ||
| 141 | @Override | ||
| 142 | public Expression getThen() | ||
| 143 | { | ||
| 144 | return then; | ||
| 145 | } | ||
| 146 | |||
| 147 | /** | ||
| 148 | * <!-- begin-user-doc --> | ||
| 149 | * <!-- end-user-doc --> | ||
| 150 | * @generated | ||
| 151 | */ | ||
| 152 | public NotificationChain basicSetThen(Expression newThen, NotificationChain msgs) | ||
| 153 | { | ||
| 154 | Expression oldThen = then; | ||
| 155 | then = newThen; | ||
| 156 | if (eNotificationRequired()) | ||
| 157 | { | ||
| 158 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__THEN, oldThen, newThen); | ||
| 159 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 160 | } | ||
| 161 | return msgs; | ||
| 162 | } | ||
| 163 | |||
| 164 | /** | ||
| 165 | * <!-- begin-user-doc --> | ||
| 166 | * <!-- end-user-doc --> | ||
| 167 | * @generated | ||
| 168 | */ | ||
| 169 | @Override | ||
| 170 | public void setThen(Expression newThen) | ||
| 171 | { | ||
| 172 | if (newThen != then) | ||
| 173 | { | ||
| 174 | NotificationChain msgs = null; | ||
| 175 | if (then != null) | ||
| 176 | msgs = ((InternalEObject)then).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__THEN, null, msgs); | ||
| 177 | if (newThen != null) | ||
| 178 | msgs = ((InternalEObject)newThen).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__THEN, null, msgs); | ||
| 179 | msgs = basicSetThen(newThen, msgs); | ||
| 180 | if (msgs != null) msgs.dispatch(); | ||
| 181 | } | ||
| 182 | else if (eNotificationRequired()) | ||
| 183 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__THEN, newThen, newThen)); | ||
| 184 | } | ||
| 185 | |||
| 186 | /** | ||
| 187 | * <!-- begin-user-doc --> | ||
| 188 | * <!-- end-user-doc --> | ||
| 189 | * @generated | ||
| 190 | */ | ||
| 191 | @Override | ||
| 192 | public Expression getElse() | ||
| 193 | { | ||
| 194 | return else_; | ||
| 195 | } | ||
| 196 | |||
| 197 | /** | ||
| 198 | * <!-- begin-user-doc --> | ||
| 199 | * <!-- end-user-doc --> | ||
| 200 | * @generated | ||
| 201 | */ | ||
| 202 | public NotificationChain basicSetElse(Expression newElse, NotificationChain msgs) | ||
| 203 | { | ||
| 204 | Expression oldElse = else_; | ||
| 205 | else_ = newElse; | ||
| 206 | if (eNotificationRequired()) | ||
| 207 | { | ||
| 208 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__ELSE, oldElse, newElse); | ||
| 209 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 210 | } | ||
| 211 | return msgs; | ||
| 212 | } | ||
| 213 | |||
| 214 | /** | ||
| 215 | * <!-- begin-user-doc --> | ||
| 216 | * <!-- end-user-doc --> | ||
| 217 | * @generated | ||
| 218 | */ | ||
| 219 | @Override | ||
| 220 | public void setElse(Expression newElse) | ||
| 221 | { | ||
| 222 | if (newElse != else_) | ||
| 223 | { | ||
| 224 | NotificationChain msgs = null; | ||
| 225 | if (else_ != null) | ||
| 226 | msgs = ((InternalEObject)else_).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__ELSE, null, msgs); | ||
| 227 | if (newElse != null) | ||
| 228 | msgs = ((InternalEObject)newElse).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.IF_ELSE__ELSE, null, msgs); | ||
| 229 | msgs = basicSetElse(newElse, msgs); | ||
| 230 | if (msgs != null) msgs.dispatch(); | ||
| 231 | } | ||
| 232 | else if (eNotificationRequired()) | ||
| 233 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.IF_ELSE__ELSE, newElse, newElse)); | ||
| 234 | } | ||
| 235 | |||
| 236 | /** | ||
| 237 | * <!-- begin-user-doc --> | ||
| 238 | * <!-- end-user-doc --> | ||
| 239 | * @generated | ||
| 240 | */ | ||
| 241 | @Override | ||
| 242 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 243 | { | ||
| 244 | switch (featureID) | ||
| 245 | { | ||
| 246 | case SolverLanguagePackage.IF_ELSE__CONDITION: | ||
| 247 | return basicSetCondition(null, msgs); | ||
| 248 | case SolverLanguagePackage.IF_ELSE__THEN: | ||
| 249 | return basicSetThen(null, msgs); | ||
| 250 | case SolverLanguagePackage.IF_ELSE__ELSE: | ||
| 251 | return basicSetElse(null, msgs); | ||
| 252 | } | ||
| 253 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 254 | } | ||
| 255 | |||
| 256 | /** | ||
| 257 | * <!-- begin-user-doc --> | ||
| 258 | * <!-- end-user-doc --> | ||
| 259 | * @generated | ||
| 260 | */ | ||
| 261 | @Override | ||
| 262 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 263 | { | ||
| 264 | switch (featureID) | ||
| 265 | { | ||
| 266 | case SolverLanguagePackage.IF_ELSE__CONDITION: | ||
| 267 | return getCondition(); | ||
| 268 | case SolverLanguagePackage.IF_ELSE__THEN: | ||
| 269 | return getThen(); | ||
| 270 | case SolverLanguagePackage.IF_ELSE__ELSE: | ||
| 271 | return getElse(); | ||
| 272 | } | ||
| 273 | return super.eGet(featureID, resolve, coreType); | ||
| 274 | } | ||
| 275 | |||
| 276 | /** | ||
| 277 | * <!-- begin-user-doc --> | ||
| 278 | * <!-- end-user-doc --> | ||
| 279 | * @generated | ||
| 280 | */ | ||
| 281 | @Override | ||
| 282 | public void eSet(int featureID, Object newValue) | ||
| 283 | { | ||
| 284 | switch (featureID) | ||
| 285 | { | ||
| 286 | case SolverLanguagePackage.IF_ELSE__CONDITION: | ||
| 287 | setCondition((Expression)newValue); | ||
| 288 | return; | ||
| 289 | case SolverLanguagePackage.IF_ELSE__THEN: | ||
| 290 | setThen((Expression)newValue); | ||
| 291 | return; | ||
| 292 | case SolverLanguagePackage.IF_ELSE__ELSE: | ||
| 293 | setElse((Expression)newValue); | ||
| 294 | return; | ||
| 295 | } | ||
| 296 | super.eSet(featureID, newValue); | ||
| 297 | } | ||
| 298 | |||
| 299 | /** | ||
| 300 | * <!-- begin-user-doc --> | ||
| 301 | * <!-- end-user-doc --> | ||
| 302 | * @generated | ||
| 303 | */ | ||
| 304 | @Override | ||
| 305 | public void eUnset(int featureID) | ||
| 306 | { | ||
| 307 | switch (featureID) | ||
| 308 | { | ||
| 309 | case SolverLanguagePackage.IF_ELSE__CONDITION: | ||
| 310 | setCondition((Expression)null); | ||
| 311 | return; | ||
| 312 | case SolverLanguagePackage.IF_ELSE__THEN: | ||
| 313 | setThen((Expression)null); | ||
| 314 | return; | ||
| 315 | case SolverLanguagePackage.IF_ELSE__ELSE: | ||
| 316 | setElse((Expression)null); | ||
| 317 | return; | ||
| 318 | } | ||
| 319 | super.eUnset(featureID); | ||
| 320 | } | ||
| 321 | |||
| 322 | /** | ||
| 323 | * <!-- begin-user-doc --> | ||
| 324 | * <!-- end-user-doc --> | ||
| 325 | * @generated | ||
| 326 | */ | ||
| 327 | @Override | ||
| 328 | public boolean eIsSet(int featureID) | ||
| 329 | { | ||
| 330 | switch (featureID) | ||
| 331 | { | ||
| 332 | case SolverLanguagePackage.IF_ELSE__CONDITION: | ||
| 333 | return condition != null; | ||
| 334 | case SolverLanguagePackage.IF_ELSE__THEN: | ||
| 335 | return then != null; | ||
| 336 | case SolverLanguagePackage.IF_ELSE__ELSE: | ||
| 337 | return else_ != null; | ||
| 338 | } | ||
| 339 | return super.eIsSet(featureID); | ||
| 340 | } | ||
| 341 | |||
| 342 | } //IfElseImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InfinityLiteralImpl.java index b1e9c3d0..e796f5a0 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InfinityLiteralImpl.java | |||
| @@ -1,28 +1,28 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | 8 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; |
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 10 | 10 | ||
| 11 | /** | 11 | /** |
| 12 | * <!-- begin-user-doc --> | 12 | * <!-- begin-user-doc --> |
| 13 | * An implementation of the model object '<em><b>All Objects</b></em>'. | 13 | * An implementation of the model object '<em><b>Infinity Literal</b></em>'. |
| 14 | * <!-- end-user-doc --> | 14 | * <!-- end-user-doc --> |
| 15 | * | 15 | * |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public class AllObjectsImpl extends ComplexObjectImpl implements AllObjects | 18 | public class InfinityLiteralImpl extends LiteralImpl implements InfinityLiteral |
| 19 | { | 19 | { |
| 20 | /** | 20 | /** |
| 21 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
| 22 | * <!-- end-user-doc --> | 22 | * <!-- end-user-doc --> |
| 23 | * @generated | 23 | * @generated |
| 24 | */ | 24 | */ |
| 25 | protected AllObjectsImpl() | 25 | protected InfinityLiteralImpl() |
| 26 | { | 26 | { |
| 27 | super(); | 27 | super(); |
| 28 | } | 28 | } |
| @@ -35,7 +35,7 @@ public class AllObjectsImpl extends ComplexObjectImpl implements AllObjects | |||
| 35 | @Override | 35 | @Override |
| 36 | protected EClass eStaticClass() | 36 | protected EClass eStaticClass() |
| 37 | { | 37 | { |
| 38 | return SolverLanguagePackage.Literals.ALL_OBJECTS; | 38 | return SolverLanguagePackage.Literals.INFINITY_LITERAL; |
| 39 | } | 39 | } |
| 40 | 40 | ||
| 41 | } //AllObjectsImpl | 41 | } //InfinityLiteralImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java deleted file mode 100644 index bcd978fa..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Integer Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class IntegerSymbolImpl extends DataSymbolImpl implements IntegerSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected IntegerSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.INTEGER_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //IntegerSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java deleted file mode 100644 index fb41d77d..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Interpretation</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class InterpretationImpl extends StatementImpl implements Interpretation | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected InterpretationImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.INTERPRETATION; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //InterpretationImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntervalImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntervalImpl.java new file mode 100644 index 00000000..e6107ef8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntervalImpl.java | |||
| @@ -0,0 +1,269 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 17 | |||
| 18 | /** | ||
| 19 | * <!-- begin-user-doc --> | ||
| 20 | * An implementation of the model object '<em><b>Interval</b></em>'. | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * <p> | ||
| 23 | * The following features are implemented: | ||
| 24 | * </p> | ||
| 25 | * <ul> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl#getLowerBound <em>Lower Bound</em>}</li> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntervalImpl#getUpperBound <em>Upper Bound</em>}</li> | ||
| 28 | * </ul> | ||
| 29 | * | ||
| 30 | * @generated | ||
| 31 | */ | ||
| 32 | public class IntervalImpl extends ExpressionImpl implements Interval | ||
| 33 | { | ||
| 34 | /** | ||
| 35 | * The cached value of the '{@link #getLowerBound() <em>Lower Bound</em>}' containment reference. | ||
| 36 | * <!-- begin-user-doc --> | ||
| 37 | * <!-- end-user-doc --> | ||
| 38 | * @see #getLowerBound() | ||
| 39 | * @generated | ||
| 40 | * @ordered | ||
| 41 | */ | ||
| 42 | protected Expression lowerBound; | ||
| 43 | |||
| 44 | /** | ||
| 45 | * The cached value of the '{@link #getUpperBound() <em>Upper Bound</em>}' containment reference. | ||
| 46 | * <!-- begin-user-doc --> | ||
| 47 | * <!-- end-user-doc --> | ||
| 48 | * @see #getUpperBound() | ||
| 49 | * @generated | ||
| 50 | * @ordered | ||
| 51 | */ | ||
| 52 | protected Expression upperBound; | ||
| 53 | |||
| 54 | /** | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @generated | ||
| 58 | */ | ||
| 59 | protected IntervalImpl() | ||
| 60 | { | ||
| 61 | super(); | ||
| 62 | } | ||
| 63 | |||
| 64 | /** | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @generated | ||
| 68 | */ | ||
| 69 | @Override | ||
| 70 | protected EClass eStaticClass() | ||
| 71 | { | ||
| 72 | return SolverLanguagePackage.Literals.INTERVAL; | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | public Expression getLowerBound() | ||
| 82 | { | ||
| 83 | return lowerBound; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | public NotificationChain basicSetLowerBound(Expression newLowerBound, NotificationChain msgs) | ||
| 92 | { | ||
| 93 | Expression oldLowerBound = lowerBound; | ||
| 94 | lowerBound = newLowerBound; | ||
| 95 | if (eNotificationRequired()) | ||
| 96 | { | ||
| 97 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INTERVAL__LOWER_BOUND, oldLowerBound, newLowerBound); | ||
| 98 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 99 | } | ||
| 100 | return msgs; | ||
| 101 | } | ||
| 102 | |||
| 103 | /** | ||
| 104 | * <!-- begin-user-doc --> | ||
| 105 | * <!-- end-user-doc --> | ||
| 106 | * @generated | ||
| 107 | */ | ||
| 108 | @Override | ||
| 109 | public void setLowerBound(Expression newLowerBound) | ||
| 110 | { | ||
| 111 | if (newLowerBound != lowerBound) | ||
| 112 | { | ||
| 113 | NotificationChain msgs = null; | ||
| 114 | if (lowerBound != null) | ||
| 115 | msgs = ((InternalEObject)lowerBound).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.INTERVAL__LOWER_BOUND, null, msgs); | ||
| 116 | if (newLowerBound != null) | ||
| 117 | msgs = ((InternalEObject)newLowerBound).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.INTERVAL__LOWER_BOUND, null, msgs); | ||
| 118 | msgs = basicSetLowerBound(newLowerBound, msgs); | ||
| 119 | if (msgs != null) msgs.dispatch(); | ||
| 120 | } | ||
| 121 | else if (eNotificationRequired()) | ||
| 122 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INTERVAL__LOWER_BOUND, newLowerBound, newLowerBound)); | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public Expression getUpperBound() | ||
| 132 | { | ||
| 133 | return upperBound; | ||
| 134 | } | ||
| 135 | |||
| 136 | /** | ||
| 137 | * <!-- begin-user-doc --> | ||
| 138 | * <!-- end-user-doc --> | ||
| 139 | * @generated | ||
| 140 | */ | ||
| 141 | public NotificationChain basicSetUpperBound(Expression newUpperBound, NotificationChain msgs) | ||
| 142 | { | ||
| 143 | Expression oldUpperBound = upperBound; | ||
| 144 | upperBound = newUpperBound; | ||
| 145 | if (eNotificationRequired()) | ||
| 146 | { | ||
| 147 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INTERVAL__UPPER_BOUND, oldUpperBound, newUpperBound); | ||
| 148 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 149 | } | ||
| 150 | return msgs; | ||
| 151 | } | ||
| 152 | |||
| 153 | /** | ||
| 154 | * <!-- begin-user-doc --> | ||
| 155 | * <!-- end-user-doc --> | ||
| 156 | * @generated | ||
| 157 | */ | ||
| 158 | @Override | ||
| 159 | public void setUpperBound(Expression newUpperBound) | ||
| 160 | { | ||
| 161 | if (newUpperBound != upperBound) | ||
| 162 | { | ||
| 163 | NotificationChain msgs = null; | ||
| 164 | if (upperBound != null) | ||
| 165 | msgs = ((InternalEObject)upperBound).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.INTERVAL__UPPER_BOUND, null, msgs); | ||
| 166 | if (newUpperBound != null) | ||
| 167 | msgs = ((InternalEObject)newUpperBound).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.INTERVAL__UPPER_BOUND, null, msgs); | ||
| 168 | msgs = basicSetUpperBound(newUpperBound, msgs); | ||
| 169 | if (msgs != null) msgs.dispatch(); | ||
| 170 | } | ||
| 171 | else if (eNotificationRequired()) | ||
| 172 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INTERVAL__UPPER_BOUND, newUpperBound, newUpperBound)); | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | @Override | ||
| 181 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 182 | { | ||
| 183 | switch (featureID) | ||
| 184 | { | ||
| 185 | case SolverLanguagePackage.INTERVAL__LOWER_BOUND: | ||
| 186 | return basicSetLowerBound(null, msgs); | ||
| 187 | case SolverLanguagePackage.INTERVAL__UPPER_BOUND: | ||
| 188 | return basicSetUpperBound(null, msgs); | ||
| 189 | } | ||
| 190 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 191 | } | ||
| 192 | |||
| 193 | /** | ||
| 194 | * <!-- begin-user-doc --> | ||
| 195 | * <!-- end-user-doc --> | ||
| 196 | * @generated | ||
| 197 | */ | ||
| 198 | @Override | ||
| 199 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 200 | { | ||
| 201 | switch (featureID) | ||
| 202 | { | ||
| 203 | case SolverLanguagePackage.INTERVAL__LOWER_BOUND: | ||
| 204 | return getLowerBound(); | ||
| 205 | case SolverLanguagePackage.INTERVAL__UPPER_BOUND: | ||
| 206 | return getUpperBound(); | ||
| 207 | } | ||
| 208 | return super.eGet(featureID, resolve, coreType); | ||
| 209 | } | ||
| 210 | |||
| 211 | /** | ||
| 212 | * <!-- begin-user-doc --> | ||
| 213 | * <!-- end-user-doc --> | ||
| 214 | * @generated | ||
| 215 | */ | ||
| 216 | @Override | ||
| 217 | public void eSet(int featureID, Object newValue) | ||
| 218 | { | ||
| 219 | switch (featureID) | ||
| 220 | { | ||
| 221 | case SolverLanguagePackage.INTERVAL__LOWER_BOUND: | ||
| 222 | setLowerBound((Expression)newValue); | ||
| 223 | return; | ||
| 224 | case SolverLanguagePackage.INTERVAL__UPPER_BOUND: | ||
| 225 | setUpperBound((Expression)newValue); | ||
| 226 | return; | ||
| 227 | } | ||
| 228 | super.eSet(featureID, newValue); | ||
| 229 | } | ||
| 230 | |||
| 231 | /** | ||
| 232 | * <!-- begin-user-doc --> | ||
| 233 | * <!-- end-user-doc --> | ||
| 234 | * @generated | ||
| 235 | */ | ||
| 236 | @Override | ||
| 237 | public void eUnset(int featureID) | ||
| 238 | { | ||
| 239 | switch (featureID) | ||
| 240 | { | ||
| 241 | case SolverLanguagePackage.INTERVAL__LOWER_BOUND: | ||
| 242 | setLowerBound((Expression)null); | ||
| 243 | return; | ||
| 244 | case SolverLanguagePackage.INTERVAL__UPPER_BOUND: | ||
| 245 | setUpperBound((Expression)null); | ||
| 246 | return; | ||
| 247 | } | ||
| 248 | super.eUnset(featureID); | ||
| 249 | } | ||
| 250 | |||
| 251 | /** | ||
| 252 | * <!-- begin-user-doc --> | ||
| 253 | * <!-- end-user-doc --> | ||
| 254 | * @generated | ||
| 255 | */ | ||
| 256 | @Override | ||
| 257 | public boolean eIsSet(int featureID) | ||
| 258 | { | ||
| 259 | switch (featureID) | ||
| 260 | { | ||
| 261 | case SolverLanguagePackage.INTERVAL__LOWER_BOUND: | ||
| 262 | return lowerBound != null; | ||
| 263 | case SolverLanguagePackage.INTERVAL__UPPER_BOUND: | ||
| 264 | return upperBound != null; | ||
| 265 | } | ||
| 266 | return super.eIsSet(featureID); | ||
| 267 | } | ||
| 268 | |||
| 269 | } //IntervalImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java deleted file mode 100644 index 07ad66f9..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Irreflexive Closure</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class IrreflexiveClosureImpl extends ClosureTypeImpl implements IrreflexiveClosure | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected IrreflexiveClosureImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.IRREFLEXIVE_CLOSURE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //IrreflexiveClosureImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java index 518aa2b7..2983566c 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java | |||
| @@ -1,12 +1,10 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 9 | |||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | 8 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; |
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 12 | 10 | ||
| @@ -17,7 +15,7 @@ import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | |||
| 17 | * | 15 | * |
| 18 | * @generated | 16 | * @generated |
| 19 | */ | 17 | */ |
| 20 | public class LiteralImpl extends MinimalEObjectImpl.Container implements Literal | 18 | public class LiteralImpl extends ExpressionImpl implements Literal |
| 21 | { | 19 | { |
| 22 | /** | 20 | /** |
| 23 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LogicLiteralImpl.java index fa844b68..2bc27a20 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LogicLiteralImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -9,23 +9,24 @@ import org.eclipse.emf.ecore.EClass; | |||
| 9 | 9 | ||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 11 | 11 | ||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; |
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.LogicValue; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 14 | 15 | ||
| 15 | /** | 16 | /** |
| 16 | * <!-- begin-user-doc --> | 17 | * <!-- begin-user-doc --> |
| 17 | * An implementation of the model object '<em><b>Int Object</b></em>'. | 18 | * An implementation of the model object '<em><b>Logic Literal</b></em>'. |
| 18 | * <!-- end-user-doc --> | 19 | * <!-- end-user-doc --> |
| 19 | * <p> | 20 | * <p> |
| 20 | * The following features are implemented: | 21 | * The following features are implemented: |
| 21 | * </p> | 22 | * </p> |
| 22 | * <ul> | 23 | * <ul> |
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl#getValue <em>Value</em>}</li> | 24 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LogicLiteralImpl#getValue <em>Value</em>}</li> |
| 24 | * </ul> | 25 | * </ul> |
| 25 | * | 26 | * |
| 26 | * @generated | 27 | * @generated |
| 27 | */ | 28 | */ |
| 28 | public class IntObjectImpl extends DataObjectImpl implements IntObject | 29 | public class LogicLiteralImpl extends LiteralImpl implements LogicLiteral |
| 29 | { | 30 | { |
| 30 | /** | 31 | /** |
| 31 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. | 32 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. |
| @@ -35,7 +36,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 35 | * @generated | 36 | * @generated |
| 36 | * @ordered | 37 | * @ordered |
| 37 | */ | 38 | */ |
| 38 | protected static final int VALUE_EDEFAULT = 0; | 39 | protected static final LogicValue VALUE_EDEFAULT = LogicValue.TRUE; |
| 39 | 40 | ||
| 40 | /** | 41 | /** |
| 41 | * The cached value of the '{@link #getValue() <em>Value</em>}' attribute. | 42 | * The cached value of the '{@link #getValue() <em>Value</em>}' attribute. |
| @@ -45,14 +46,14 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 45 | * @generated | 46 | * @generated |
| 46 | * @ordered | 47 | * @ordered |
| 47 | */ | 48 | */ |
| 48 | protected int value = VALUE_EDEFAULT; | 49 | protected LogicValue value = VALUE_EDEFAULT; |
| 49 | 50 | ||
| 50 | /** | 51 | /** |
| 51 | * <!-- begin-user-doc --> | 52 | * <!-- begin-user-doc --> |
| 52 | * <!-- end-user-doc --> | 53 | * <!-- end-user-doc --> |
| 53 | * @generated | 54 | * @generated |
| 54 | */ | 55 | */ |
| 55 | protected IntObjectImpl() | 56 | protected LogicLiteralImpl() |
| 56 | { | 57 | { |
| 57 | super(); | 58 | super(); |
| 58 | } | 59 | } |
| @@ -65,7 +66,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 65 | @Override | 66 | @Override |
| 66 | protected EClass eStaticClass() | 67 | protected EClass eStaticClass() |
| 67 | { | 68 | { |
| 68 | return SolverLanguagePackage.Literals.INT_OBJECT; | 69 | return SolverLanguagePackage.Literals.LOGIC_LITERAL; |
| 69 | } | 70 | } |
| 70 | 71 | ||
| 71 | /** | 72 | /** |
| @@ -74,7 +75,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 74 | * @generated | 75 | * @generated |
| 75 | */ | 76 | */ |
| 76 | @Override | 77 | @Override |
| 77 | public int getValue() | 78 | public LogicValue getValue() |
| 78 | { | 79 | { |
| 79 | return value; | 80 | return value; |
| 80 | } | 81 | } |
| @@ -85,12 +86,12 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 85 | * @generated | 86 | * @generated |
| 86 | */ | 87 | */ |
| 87 | @Override | 88 | @Override |
| 88 | public void setValue(int newValue) | 89 | public void setValue(LogicValue newValue) |
| 89 | { | 90 | { |
| 90 | int oldValue = value; | 91 | LogicValue oldValue = value; |
| 91 | value = newValue; | 92 | value = newValue == null ? VALUE_EDEFAULT : newValue; |
| 92 | if (eNotificationRequired()) | 93 | if (eNotificationRequired()) |
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INT_OBJECT__VALUE, oldValue, value)); | 94 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.LOGIC_LITERAL__VALUE, oldValue, value)); |
| 94 | } | 95 | } |
| 95 | 96 | ||
| 96 | /** | 97 | /** |
| @@ -103,7 +104,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 103 | { | 104 | { |
| 104 | switch (featureID) | 105 | switch (featureID) |
| 105 | { | 106 | { |
| 106 | case SolverLanguagePackage.INT_OBJECT__VALUE: | 107 | case SolverLanguagePackage.LOGIC_LITERAL__VALUE: |
| 107 | return getValue(); | 108 | return getValue(); |
| 108 | } | 109 | } |
| 109 | return super.eGet(featureID, resolve, coreType); | 110 | return super.eGet(featureID, resolve, coreType); |
| @@ -119,8 +120,8 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 119 | { | 120 | { |
| 120 | switch (featureID) | 121 | switch (featureID) |
| 121 | { | 122 | { |
| 122 | case SolverLanguagePackage.INT_OBJECT__VALUE: | 123 | case SolverLanguagePackage.LOGIC_LITERAL__VALUE: |
| 123 | setValue((Integer)newValue); | 124 | setValue((LogicValue)newValue); |
| 124 | return; | 125 | return; |
| 125 | } | 126 | } |
| 126 | super.eSet(featureID, newValue); | 127 | super.eSet(featureID, newValue); |
| @@ -136,7 +137,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 136 | { | 137 | { |
| 137 | switch (featureID) | 138 | switch (featureID) |
| 138 | { | 139 | { |
| 139 | case SolverLanguagePackage.INT_OBJECT__VALUE: | 140 | case SolverLanguagePackage.LOGIC_LITERAL__VALUE: |
| 140 | setValue(VALUE_EDEFAULT); | 141 | setValue(VALUE_EDEFAULT); |
| 141 | return; | 142 | return; |
| 142 | } | 143 | } |
| @@ -153,7 +154,7 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 153 | { | 154 | { |
| 154 | switch (featureID) | 155 | switch (featureID) |
| 155 | { | 156 | { |
| 156 | case SolverLanguagePackage.INT_OBJECT__VALUE: | 157 | case SolverLanguagePackage.LOGIC_LITERAL__VALUE: |
| 157 | return value != VALUE_EDEFAULT; | 158 | return value != VALUE_EDEFAULT; |
| 158 | } | 159 | } |
| 159 | return super.eIsSet(featureID); | 160 | return super.eIsSet(featureID); |
| @@ -176,4 +177,4 @@ public class IntObjectImpl extends DataObjectImpl implements IntObject | |||
| 176 | return result.toString(); | 177 | return result.toString(); |
| 177 | } | 178 | } |
| 178 | 179 | ||
| 179 | } //IntObjectImpl | 180 | } //LogicLiteralImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LowerBoundedScopeDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LowerBoundedScopeDefinitionImpl.java new file mode 100644 index 00000000..5eb671f3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LowerBoundedScopeDefinitionImpl.java | |||
| @@ -0,0 +1,179 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Lower Bounded Scope Definition</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LowerBoundedScopeDefinitionImpl#getLowerBound <em>Lower Bound</em>}</li> | ||
| 24 | * </ul> | ||
| 25 | * | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public class LowerBoundedScopeDefinitionImpl extends ScopeDefinitionImpl implements LowerBoundedScopeDefinition | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * The default value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @see #getLowerBound() | ||
| 35 | * @generated | ||
| 36 | * @ordered | ||
| 37 | */ | ||
| 38 | protected static final int LOWER_BOUND_EDEFAULT = 0; | ||
| 39 | |||
| 40 | /** | ||
| 41 | * The cached value of the '{@link #getLowerBound() <em>Lower Bound</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @see #getLowerBound() | ||
| 45 | * @generated | ||
| 46 | * @ordered | ||
| 47 | */ | ||
| 48 | protected int lowerBound = LOWER_BOUND_EDEFAULT; | ||
| 49 | |||
| 50 | /** | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @generated | ||
| 54 | */ | ||
| 55 | protected LowerBoundedScopeDefinitionImpl() | ||
| 56 | { | ||
| 57 | super(); | ||
| 58 | } | ||
| 59 | |||
| 60 | /** | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @generated | ||
| 64 | */ | ||
| 65 | @Override | ||
| 66 | protected EClass eStaticClass() | ||
| 67 | { | ||
| 68 | return SolverLanguagePackage.Literals.LOWER_BOUNDED_SCOPE_DEFINITION; | ||
| 69 | } | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | @Override | ||
| 77 | public int getLowerBound() | ||
| 78 | { | ||
| 79 | return lowerBound; | ||
| 80 | } | ||
| 81 | |||
| 82 | /** | ||
| 83 | * <!-- begin-user-doc --> | ||
| 84 | * <!-- end-user-doc --> | ||
| 85 | * @generated | ||
| 86 | */ | ||
| 87 | @Override | ||
| 88 | public void setLowerBound(int newLowerBound) | ||
| 89 | { | ||
| 90 | int oldLowerBound = lowerBound; | ||
| 91 | lowerBound = newLowerBound; | ||
| 92 | if (eNotificationRequired()) | ||
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND, oldLowerBound, lowerBound)); | ||
| 94 | } | ||
| 95 | |||
| 96 | /** | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @generated | ||
| 100 | */ | ||
| 101 | @Override | ||
| 102 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 103 | { | ||
| 104 | switch (featureID) | ||
| 105 | { | ||
| 106 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 107 | return getLowerBound(); | ||
| 108 | } | ||
| 109 | return super.eGet(featureID, resolve, coreType); | ||
| 110 | } | ||
| 111 | |||
| 112 | /** | ||
| 113 | * <!-- begin-user-doc --> | ||
| 114 | * <!-- end-user-doc --> | ||
| 115 | * @generated | ||
| 116 | */ | ||
| 117 | @Override | ||
| 118 | public void eSet(int featureID, Object newValue) | ||
| 119 | { | ||
| 120 | switch (featureID) | ||
| 121 | { | ||
| 122 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 123 | setLowerBound((Integer)newValue); | ||
| 124 | return; | ||
| 125 | } | ||
| 126 | super.eSet(featureID, newValue); | ||
| 127 | } | ||
| 128 | |||
| 129 | /** | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @generated | ||
| 133 | */ | ||
| 134 | @Override | ||
| 135 | public void eUnset(int featureID) | ||
| 136 | { | ||
| 137 | switch (featureID) | ||
| 138 | { | ||
| 139 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 140 | setLowerBound(LOWER_BOUND_EDEFAULT); | ||
| 141 | return; | ||
| 142 | } | ||
| 143 | super.eUnset(featureID); | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | @Override | ||
| 152 | public boolean eIsSet(int featureID) | ||
| 153 | { | ||
| 154 | switch (featureID) | ||
| 155 | { | ||
| 156 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND: | ||
| 157 | return lowerBound != LOWER_BOUND_EDEFAULT; | ||
| 158 | } | ||
| 159 | return super.eIsSet(featureID); | ||
| 160 | } | ||
| 161 | |||
| 162 | /** | ||
| 163 | * <!-- begin-user-doc --> | ||
| 164 | * <!-- end-user-doc --> | ||
| 165 | * @generated | ||
| 166 | */ | ||
| 167 | @Override | ||
| 168 | public String toString() | ||
| 169 | { | ||
| 170 | if (eIsProxy()) return super.toString(); | ||
| 171 | |||
| 172 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 173 | result.append(" (lowerBound: "); | ||
| 174 | result.append(lowerBound); | ||
| 175 | result.append(')'); | ||
| 176 | return result.toString(); | ||
| 177 | } | ||
| 178 | |||
| 179 | } //LowerBoundedScopeDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ManyMultiplicityImpl.java index ae78f540..c248b4ea 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ManyMultiplicityImpl.java | |||
| @@ -1,28 +1,28 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | 8 | import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity; |
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 10 | 10 | ||
| 11 | /** | 11 | /** |
| 12 | * <!-- begin-user-doc --> | 12 | * <!-- begin-user-doc --> |
| 13 | * An implementation of the model object '<em><b>Boolean False</b></em>'. | 13 | * An implementation of the model object '<em><b>Many Multiplicity</b></em>'. |
| 14 | * <!-- end-user-doc --> | 14 | * <!-- end-user-doc --> |
| 15 | * | 15 | * |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public class BooleanFalseImpl extends BooleanValueImpl implements BooleanFalse | 18 | public class ManyMultiplicityImpl extends MultiplicityImpl implements ManyMultiplicity |
| 19 | { | 19 | { |
| 20 | /** | 20 | /** |
| 21 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
| 22 | * <!-- end-user-doc --> | 22 | * <!-- end-user-doc --> |
| 23 | * @generated | 23 | * @generated |
| 24 | */ | 24 | */ |
| 25 | protected BooleanFalseImpl() | 25 | protected ManyMultiplicityImpl() |
| 26 | { | 26 | { |
| 27 | super(); | 27 | super(); |
| 28 | } | 28 | } |
| @@ -35,7 +35,7 @@ public class BooleanFalseImpl extends BooleanValueImpl implements BooleanFalse | |||
| 35 | @Override | 35 | @Override |
| 36 | protected EClass eStaticClass() | 36 | protected EClass eStaticClass() |
| 37 | { | 37 | { |
| 38 | return SolverLanguagePackage.Literals.BOOLEAN_FALSE; | 38 | return SolverLanguagePackage.Literals.MANY_MULTIPLICITY; |
| 39 | } | 39 | } |
| 40 | 40 | ||
| 41 | } //BooleanFalseImpl | 41 | } //ManyMultiplicityImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MemberDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MemberDefinitionImpl.java new file mode 100644 index 00000000..69021347 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MemberDefinitionImpl.java | |||
| @@ -0,0 +1,463 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 14 | |||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.Multiplicity; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 19 | |||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * An implementation of the model object '<em><b>Member Definition</b></em>'. | ||
| 23 | * <!-- end-user-doc --> | ||
| 24 | * <p> | ||
| 25 | * The following features are implemented: | ||
| 26 | * </p> | ||
| 27 | * <ul> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl#isContainment <em>Containment</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl#getType <em>Type</em>}</li> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl#getMultiplicity <em>Multiplicity</em>}</li> | ||
| 31 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl#getName <em>Name</em>}</li> | ||
| 32 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MemberDefinitionImpl#getOpposite <em>Opposite</em>}</li> | ||
| 33 | * </ul> | ||
| 34 | * | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | public class MemberDefinitionImpl extends MinimalEObjectImpl.Container implements MemberDefinition | ||
| 38 | { | ||
| 39 | /** | ||
| 40 | * The default value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 41 | * <!-- begin-user-doc --> | ||
| 42 | * <!-- end-user-doc --> | ||
| 43 | * @see #isContainment() | ||
| 44 | * @generated | ||
| 45 | * @ordered | ||
| 46 | */ | ||
| 47 | protected static final boolean CONTAINMENT_EDEFAULT = false; | ||
| 48 | |||
| 49 | /** | ||
| 50 | * The cached value of the '{@link #isContainment() <em>Containment</em>}' attribute. | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @see #isContainment() | ||
| 54 | * @generated | ||
| 55 | * @ordered | ||
| 56 | */ | ||
| 57 | protected boolean containment = CONTAINMENT_EDEFAULT; | ||
| 58 | |||
| 59 | /** | ||
| 60 | * The cached value of the '{@link #getType() <em>Type</em>}' reference. | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @see #getType() | ||
| 64 | * @generated | ||
| 65 | * @ordered | ||
| 66 | */ | ||
| 67 | protected NamedElement type; | ||
| 68 | |||
| 69 | /** | ||
| 70 | * The cached value of the '{@link #getMultiplicity() <em>Multiplicity</em>}' containment reference. | ||
| 71 | * <!-- begin-user-doc --> | ||
| 72 | * <!-- end-user-doc --> | ||
| 73 | * @see #getMultiplicity() | ||
| 74 | * @generated | ||
| 75 | * @ordered | ||
| 76 | */ | ||
| 77 | protected Multiplicity multiplicity; | ||
| 78 | |||
| 79 | /** | ||
| 80 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 81 | * <!-- begin-user-doc --> | ||
| 82 | * <!-- end-user-doc --> | ||
| 83 | * @see #getName() | ||
| 84 | * @generated | ||
| 85 | * @ordered | ||
| 86 | */ | ||
| 87 | protected static final String NAME_EDEFAULT = null; | ||
| 88 | |||
| 89 | /** | ||
| 90 | * The cached value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 91 | * <!-- begin-user-doc --> | ||
| 92 | * <!-- end-user-doc --> | ||
| 93 | * @see #getName() | ||
| 94 | * @generated | ||
| 95 | * @ordered | ||
| 96 | */ | ||
| 97 | protected String name = NAME_EDEFAULT; | ||
| 98 | |||
| 99 | /** | ||
| 100 | * The cached value of the '{@link #getOpposite() <em>Opposite</em>}' reference. | ||
| 101 | * <!-- begin-user-doc --> | ||
| 102 | * <!-- end-user-doc --> | ||
| 103 | * @see #getOpposite() | ||
| 104 | * @generated | ||
| 105 | * @ordered | ||
| 106 | */ | ||
| 107 | protected NamedElement opposite; | ||
| 108 | |||
| 109 | /** | ||
| 110 | * <!-- begin-user-doc --> | ||
| 111 | * <!-- end-user-doc --> | ||
| 112 | * @generated | ||
| 113 | */ | ||
| 114 | protected MemberDefinitionImpl() | ||
| 115 | { | ||
| 116 | super(); | ||
| 117 | } | ||
| 118 | |||
| 119 | /** | ||
| 120 | * <!-- begin-user-doc --> | ||
| 121 | * <!-- end-user-doc --> | ||
| 122 | * @generated | ||
| 123 | */ | ||
| 124 | @Override | ||
| 125 | protected EClass eStaticClass() | ||
| 126 | { | ||
| 127 | return SolverLanguagePackage.Literals.MEMBER_DEFINITION; | ||
| 128 | } | ||
| 129 | |||
| 130 | /** | ||
| 131 | * <!-- begin-user-doc --> | ||
| 132 | * <!-- end-user-doc --> | ||
| 133 | * @generated | ||
| 134 | */ | ||
| 135 | @Override | ||
| 136 | public boolean isContainment() | ||
| 137 | { | ||
| 138 | return containment; | ||
| 139 | } | ||
| 140 | |||
| 141 | /** | ||
| 142 | * <!-- begin-user-doc --> | ||
| 143 | * <!-- end-user-doc --> | ||
| 144 | * @generated | ||
| 145 | */ | ||
| 146 | @Override | ||
| 147 | public void setContainment(boolean newContainment) | ||
| 148 | { | ||
| 149 | boolean oldContainment = containment; | ||
| 150 | containment = newContainment; | ||
| 151 | if (eNotificationRequired()) | ||
| 152 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__CONTAINMENT, oldContainment, containment)); | ||
| 153 | } | ||
| 154 | |||
| 155 | /** | ||
| 156 | * <!-- begin-user-doc --> | ||
| 157 | * <!-- end-user-doc --> | ||
| 158 | * @generated | ||
| 159 | */ | ||
| 160 | @Override | ||
| 161 | public NamedElement getType() | ||
| 162 | { | ||
| 163 | if (type != null && type.eIsProxy()) | ||
| 164 | { | ||
| 165 | InternalEObject oldType = (InternalEObject)type; | ||
| 166 | type = (NamedElement)eResolveProxy(oldType); | ||
| 167 | if (type != oldType) | ||
| 168 | { | ||
| 169 | if (eNotificationRequired()) | ||
| 170 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.MEMBER_DEFINITION__TYPE, oldType, type)); | ||
| 171 | } | ||
| 172 | } | ||
| 173 | return type; | ||
| 174 | } | ||
| 175 | |||
| 176 | /** | ||
| 177 | * <!-- begin-user-doc --> | ||
| 178 | * <!-- end-user-doc --> | ||
| 179 | * @generated | ||
| 180 | */ | ||
| 181 | public NamedElement basicGetType() | ||
| 182 | { | ||
| 183 | return type; | ||
| 184 | } | ||
| 185 | |||
| 186 | /** | ||
| 187 | * <!-- begin-user-doc --> | ||
| 188 | * <!-- end-user-doc --> | ||
| 189 | * @generated | ||
| 190 | */ | ||
| 191 | @Override | ||
| 192 | public void setType(NamedElement newType) | ||
| 193 | { | ||
| 194 | NamedElement oldType = type; | ||
| 195 | type = newType; | ||
| 196 | if (eNotificationRequired()) | ||
| 197 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__TYPE, oldType, type)); | ||
| 198 | } | ||
| 199 | |||
| 200 | /** | ||
| 201 | * <!-- begin-user-doc --> | ||
| 202 | * <!-- end-user-doc --> | ||
| 203 | * @generated | ||
| 204 | */ | ||
| 205 | @Override | ||
| 206 | public Multiplicity getMultiplicity() | ||
| 207 | { | ||
| 208 | return multiplicity; | ||
| 209 | } | ||
| 210 | |||
| 211 | /** | ||
| 212 | * <!-- begin-user-doc --> | ||
| 213 | * <!-- end-user-doc --> | ||
| 214 | * @generated | ||
| 215 | */ | ||
| 216 | public NotificationChain basicSetMultiplicity(Multiplicity newMultiplicity, NotificationChain msgs) | ||
| 217 | { | ||
| 218 | Multiplicity oldMultiplicity = multiplicity; | ||
| 219 | multiplicity = newMultiplicity; | ||
| 220 | if (eNotificationRequired()) | ||
| 221 | { | ||
| 222 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY, oldMultiplicity, newMultiplicity); | ||
| 223 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 224 | } | ||
| 225 | return msgs; | ||
| 226 | } | ||
| 227 | |||
| 228 | /** | ||
| 229 | * <!-- begin-user-doc --> | ||
| 230 | * <!-- end-user-doc --> | ||
| 231 | * @generated | ||
| 232 | */ | ||
| 233 | @Override | ||
| 234 | public void setMultiplicity(Multiplicity newMultiplicity) | ||
| 235 | { | ||
| 236 | if (newMultiplicity != multiplicity) | ||
| 237 | { | ||
| 238 | NotificationChain msgs = null; | ||
| 239 | if (multiplicity != null) | ||
| 240 | msgs = ((InternalEObject)multiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY, null, msgs); | ||
| 241 | if (newMultiplicity != null) | ||
| 242 | msgs = ((InternalEObject)newMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY, null, msgs); | ||
| 243 | msgs = basicSetMultiplicity(newMultiplicity, msgs); | ||
| 244 | if (msgs != null) msgs.dispatch(); | ||
| 245 | } | ||
| 246 | else if (eNotificationRequired()) | ||
| 247 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY, newMultiplicity, newMultiplicity)); | ||
| 248 | } | ||
| 249 | |||
| 250 | /** | ||
| 251 | * <!-- begin-user-doc --> | ||
| 252 | * <!-- end-user-doc --> | ||
| 253 | * @generated | ||
| 254 | */ | ||
| 255 | @Override | ||
| 256 | public String getName() | ||
| 257 | { | ||
| 258 | return name; | ||
| 259 | } | ||
| 260 | |||
| 261 | /** | ||
| 262 | * <!-- begin-user-doc --> | ||
| 263 | * <!-- end-user-doc --> | ||
| 264 | * @generated | ||
| 265 | */ | ||
| 266 | @Override | ||
| 267 | public void setName(String newName) | ||
| 268 | { | ||
| 269 | String oldName = name; | ||
| 270 | name = newName; | ||
| 271 | if (eNotificationRequired()) | ||
| 272 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__NAME, oldName, name)); | ||
| 273 | } | ||
| 274 | |||
| 275 | /** | ||
| 276 | * <!-- begin-user-doc --> | ||
| 277 | * <!-- end-user-doc --> | ||
| 278 | * @generated | ||
| 279 | */ | ||
| 280 | @Override | ||
| 281 | public NamedElement getOpposite() | ||
| 282 | { | ||
| 283 | if (opposite != null && opposite.eIsProxy()) | ||
| 284 | { | ||
| 285 | InternalEObject oldOpposite = (InternalEObject)opposite; | ||
| 286 | opposite = (NamedElement)eResolveProxy(oldOpposite); | ||
| 287 | if (opposite != oldOpposite) | ||
| 288 | { | ||
| 289 | if (eNotificationRequired()) | ||
| 290 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE, oldOpposite, opposite)); | ||
| 291 | } | ||
| 292 | } | ||
| 293 | return opposite; | ||
| 294 | } | ||
| 295 | |||
| 296 | /** | ||
| 297 | * <!-- begin-user-doc --> | ||
| 298 | * <!-- end-user-doc --> | ||
| 299 | * @generated | ||
| 300 | */ | ||
| 301 | public NamedElement basicGetOpposite() | ||
| 302 | { | ||
| 303 | return opposite; | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public void setOpposite(NamedElement newOpposite) | ||
| 313 | { | ||
| 314 | NamedElement oldOpposite = opposite; | ||
| 315 | opposite = newOpposite; | ||
| 316 | if (eNotificationRequired()) | ||
| 317 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE, oldOpposite, opposite)); | ||
| 318 | } | ||
| 319 | |||
| 320 | /** | ||
| 321 | * <!-- begin-user-doc --> | ||
| 322 | * <!-- end-user-doc --> | ||
| 323 | * @generated | ||
| 324 | */ | ||
| 325 | @Override | ||
| 326 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 327 | { | ||
| 328 | switch (featureID) | ||
| 329 | { | ||
| 330 | case SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY: | ||
| 331 | return basicSetMultiplicity(null, msgs); | ||
| 332 | } | ||
| 333 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 334 | } | ||
| 335 | |||
| 336 | /** | ||
| 337 | * <!-- begin-user-doc --> | ||
| 338 | * <!-- end-user-doc --> | ||
| 339 | * @generated | ||
| 340 | */ | ||
| 341 | @Override | ||
| 342 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 343 | { | ||
| 344 | switch (featureID) | ||
| 345 | { | ||
| 346 | case SolverLanguagePackage.MEMBER_DEFINITION__CONTAINMENT: | ||
| 347 | return isContainment(); | ||
| 348 | case SolverLanguagePackage.MEMBER_DEFINITION__TYPE: | ||
| 349 | if (resolve) return getType(); | ||
| 350 | return basicGetType(); | ||
| 351 | case SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY: | ||
| 352 | return getMultiplicity(); | ||
| 353 | case SolverLanguagePackage.MEMBER_DEFINITION__NAME: | ||
| 354 | return getName(); | ||
| 355 | case SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE: | ||
| 356 | if (resolve) return getOpposite(); | ||
| 357 | return basicGetOpposite(); | ||
| 358 | } | ||
| 359 | return super.eGet(featureID, resolve, coreType); | ||
| 360 | } | ||
| 361 | |||
| 362 | /** | ||
| 363 | * <!-- begin-user-doc --> | ||
| 364 | * <!-- end-user-doc --> | ||
| 365 | * @generated | ||
| 366 | */ | ||
| 367 | @Override | ||
| 368 | public void eSet(int featureID, Object newValue) | ||
| 369 | { | ||
| 370 | switch (featureID) | ||
| 371 | { | ||
| 372 | case SolverLanguagePackage.MEMBER_DEFINITION__CONTAINMENT: | ||
| 373 | setContainment((Boolean)newValue); | ||
| 374 | return; | ||
| 375 | case SolverLanguagePackage.MEMBER_DEFINITION__TYPE: | ||
| 376 | setType((NamedElement)newValue); | ||
| 377 | return; | ||
| 378 | case SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY: | ||
| 379 | setMultiplicity((Multiplicity)newValue); | ||
| 380 | return; | ||
| 381 | case SolverLanguagePackage.MEMBER_DEFINITION__NAME: | ||
| 382 | setName((String)newValue); | ||
| 383 | return; | ||
| 384 | case SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE: | ||
| 385 | setOpposite((NamedElement)newValue); | ||
| 386 | return; | ||
| 387 | } | ||
| 388 | super.eSet(featureID, newValue); | ||
| 389 | } | ||
| 390 | |||
| 391 | /** | ||
| 392 | * <!-- begin-user-doc --> | ||
| 393 | * <!-- end-user-doc --> | ||
| 394 | * @generated | ||
| 395 | */ | ||
| 396 | @Override | ||
| 397 | public void eUnset(int featureID) | ||
| 398 | { | ||
| 399 | switch (featureID) | ||
| 400 | { | ||
| 401 | case SolverLanguagePackage.MEMBER_DEFINITION__CONTAINMENT: | ||
| 402 | setContainment(CONTAINMENT_EDEFAULT); | ||
| 403 | return; | ||
| 404 | case SolverLanguagePackage.MEMBER_DEFINITION__TYPE: | ||
| 405 | setType((NamedElement)null); | ||
| 406 | return; | ||
| 407 | case SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY: | ||
| 408 | setMultiplicity((Multiplicity)null); | ||
| 409 | return; | ||
| 410 | case SolverLanguagePackage.MEMBER_DEFINITION__NAME: | ||
| 411 | setName(NAME_EDEFAULT); | ||
| 412 | return; | ||
| 413 | case SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE: | ||
| 414 | setOpposite((NamedElement)null); | ||
| 415 | return; | ||
| 416 | } | ||
| 417 | super.eUnset(featureID); | ||
| 418 | } | ||
| 419 | |||
| 420 | /** | ||
| 421 | * <!-- begin-user-doc --> | ||
| 422 | * <!-- end-user-doc --> | ||
| 423 | * @generated | ||
| 424 | */ | ||
| 425 | @Override | ||
| 426 | public boolean eIsSet(int featureID) | ||
| 427 | { | ||
| 428 | switch (featureID) | ||
| 429 | { | ||
| 430 | case SolverLanguagePackage.MEMBER_DEFINITION__CONTAINMENT: | ||
| 431 | return containment != CONTAINMENT_EDEFAULT; | ||
| 432 | case SolverLanguagePackage.MEMBER_DEFINITION__TYPE: | ||
| 433 | return type != null; | ||
| 434 | case SolverLanguagePackage.MEMBER_DEFINITION__MULTIPLICITY: | ||
| 435 | return multiplicity != null; | ||
| 436 | case SolverLanguagePackage.MEMBER_DEFINITION__NAME: | ||
| 437 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | ||
| 438 | case SolverLanguagePackage.MEMBER_DEFINITION__OPPOSITE: | ||
| 439 | return opposite != null; | ||
| 440 | } | ||
| 441 | return super.eIsSet(featureID); | ||
| 442 | } | ||
| 443 | |||
| 444 | /** | ||
| 445 | * <!-- begin-user-doc --> | ||
| 446 | * <!-- end-user-doc --> | ||
| 447 | * @generated | ||
| 448 | */ | ||
| 449 | @Override | ||
| 450 | public String toString() | ||
| 451 | { | ||
| 452 | if (eIsProxy()) return super.toString(); | ||
| 453 | |||
| 454 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 455 | result.append(" (containment: "); | ||
| 456 | result.append(containment); | ||
| 457 | result.append(", name: "); | ||
| 458 | result.append(name); | ||
| 459 | result.append(')'); | ||
| 460 | return result.toString(); | ||
| 461 | } | ||
| 462 | |||
| 463 | } //MemberDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MetricDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MetricDefinitionImpl.java new file mode 100644 index 00000000..8f84d2f1 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MetricDefinitionImpl.java | |||
| @@ -0,0 +1,343 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.MetricType; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Metric Definition</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl#getHead <em>Head</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl#getBody <em>Body</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MetricDefinitionImpl#getType <em>Type</em>}</li> | ||
| 30 | * </ul> | ||
| 31 | * | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | public class MetricDefinitionImpl extends StatementImpl implements MetricDefinition | ||
| 35 | { | ||
| 36 | /** | ||
| 37 | * The cached value of the '{@link #getHead() <em>Head</em>}' containment reference. | ||
| 38 | * <!-- begin-user-doc --> | ||
| 39 | * <!-- end-user-doc --> | ||
| 40 | * @see #getHead() | ||
| 41 | * @generated | ||
| 42 | * @ordered | ||
| 43 | */ | ||
| 44 | protected Expression head; | ||
| 45 | |||
| 46 | /** | ||
| 47 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @see #getBody() | ||
| 51 | * @generated | ||
| 52 | * @ordered | ||
| 53 | */ | ||
| 54 | protected Expression body; | ||
| 55 | |||
| 56 | /** | ||
| 57 | * The default value of the '{@link #getType() <em>Type</em>}' attribute. | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @see #getType() | ||
| 61 | * @generated | ||
| 62 | * @ordered | ||
| 63 | */ | ||
| 64 | protected static final MetricType TYPE_EDEFAULT = MetricType.INT; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * The cached value of the '{@link #getType() <em>Type</em>}' attribute. | ||
| 68 | * <!-- begin-user-doc --> | ||
| 69 | * <!-- end-user-doc --> | ||
| 70 | * @see #getType() | ||
| 71 | * @generated | ||
| 72 | * @ordered | ||
| 73 | */ | ||
| 74 | protected MetricType type = TYPE_EDEFAULT; | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | protected MetricDefinitionImpl() | ||
| 82 | { | ||
| 83 | super(); | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | protected EClass eStaticClass() | ||
| 93 | { | ||
| 94 | return SolverLanguagePackage.Literals.METRIC_DEFINITION; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public Expression getHead() | ||
| 104 | { | ||
| 105 | return head; | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | public NotificationChain basicSetHead(Expression newHead, NotificationChain msgs) | ||
| 114 | { | ||
| 115 | Expression oldHead = head; | ||
| 116 | head = newHead; | ||
| 117 | if (eNotificationRequired()) | ||
| 118 | { | ||
| 119 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.METRIC_DEFINITION__HEAD, oldHead, newHead); | ||
| 120 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 121 | } | ||
| 122 | return msgs; | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void setHead(Expression newHead) | ||
| 132 | { | ||
| 133 | if (newHead != head) | ||
| 134 | { | ||
| 135 | NotificationChain msgs = null; | ||
| 136 | if (head != null) | ||
| 137 | msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.METRIC_DEFINITION__HEAD, null, msgs); | ||
| 138 | if (newHead != null) | ||
| 139 | msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.METRIC_DEFINITION__HEAD, null, msgs); | ||
| 140 | msgs = basicSetHead(newHead, msgs); | ||
| 141 | if (msgs != null) msgs.dispatch(); | ||
| 142 | } | ||
| 143 | else if (eNotificationRequired()) | ||
| 144 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.METRIC_DEFINITION__HEAD, newHead, newHead)); | ||
| 145 | } | ||
| 146 | |||
| 147 | /** | ||
| 148 | * <!-- begin-user-doc --> | ||
| 149 | * <!-- end-user-doc --> | ||
| 150 | * @generated | ||
| 151 | */ | ||
| 152 | @Override | ||
| 153 | public Expression getBody() | ||
| 154 | { | ||
| 155 | return body; | ||
| 156 | } | ||
| 157 | |||
| 158 | /** | ||
| 159 | * <!-- begin-user-doc --> | ||
| 160 | * <!-- end-user-doc --> | ||
| 161 | * @generated | ||
| 162 | */ | ||
| 163 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 164 | { | ||
| 165 | Expression oldBody = body; | ||
| 166 | body = newBody; | ||
| 167 | if (eNotificationRequired()) | ||
| 168 | { | ||
| 169 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.METRIC_DEFINITION__BODY, oldBody, newBody); | ||
| 170 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 171 | } | ||
| 172 | return msgs; | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | @Override | ||
| 181 | public void setBody(Expression newBody) | ||
| 182 | { | ||
| 183 | if (newBody != body) | ||
| 184 | { | ||
| 185 | NotificationChain msgs = null; | ||
| 186 | if (body != null) | ||
| 187 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.METRIC_DEFINITION__BODY, null, msgs); | ||
| 188 | if (newBody != null) | ||
| 189 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.METRIC_DEFINITION__BODY, null, msgs); | ||
| 190 | msgs = basicSetBody(newBody, msgs); | ||
| 191 | if (msgs != null) msgs.dispatch(); | ||
| 192 | } | ||
| 193 | else if (eNotificationRequired()) | ||
| 194 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.METRIC_DEFINITION__BODY, newBody, newBody)); | ||
| 195 | } | ||
| 196 | |||
| 197 | /** | ||
| 198 | * <!-- begin-user-doc --> | ||
| 199 | * <!-- end-user-doc --> | ||
| 200 | * @generated | ||
| 201 | */ | ||
| 202 | @Override | ||
| 203 | public MetricType getType() | ||
| 204 | { | ||
| 205 | return type; | ||
| 206 | } | ||
| 207 | |||
| 208 | /** | ||
| 209 | * <!-- begin-user-doc --> | ||
| 210 | * <!-- end-user-doc --> | ||
| 211 | * @generated | ||
| 212 | */ | ||
| 213 | @Override | ||
| 214 | public void setType(MetricType newType) | ||
| 215 | { | ||
| 216 | MetricType oldType = type; | ||
| 217 | type = newType == null ? TYPE_EDEFAULT : newType; | ||
| 218 | if (eNotificationRequired()) | ||
| 219 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.METRIC_DEFINITION__TYPE, oldType, type)); | ||
| 220 | } | ||
| 221 | |||
| 222 | /** | ||
| 223 | * <!-- begin-user-doc --> | ||
| 224 | * <!-- end-user-doc --> | ||
| 225 | * @generated | ||
| 226 | */ | ||
| 227 | @Override | ||
| 228 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 229 | { | ||
| 230 | switch (featureID) | ||
| 231 | { | ||
| 232 | case SolverLanguagePackage.METRIC_DEFINITION__HEAD: | ||
| 233 | return basicSetHead(null, msgs); | ||
| 234 | case SolverLanguagePackage.METRIC_DEFINITION__BODY: | ||
| 235 | return basicSetBody(null, msgs); | ||
| 236 | } | ||
| 237 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 238 | } | ||
| 239 | |||
| 240 | /** | ||
| 241 | * <!-- begin-user-doc --> | ||
| 242 | * <!-- end-user-doc --> | ||
| 243 | * @generated | ||
| 244 | */ | ||
| 245 | @Override | ||
| 246 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 247 | { | ||
| 248 | switch (featureID) | ||
| 249 | { | ||
| 250 | case SolverLanguagePackage.METRIC_DEFINITION__HEAD: | ||
| 251 | return getHead(); | ||
| 252 | case SolverLanguagePackage.METRIC_DEFINITION__BODY: | ||
| 253 | return getBody(); | ||
| 254 | case SolverLanguagePackage.METRIC_DEFINITION__TYPE: | ||
| 255 | return getType(); | ||
| 256 | } | ||
| 257 | return super.eGet(featureID, resolve, coreType); | ||
| 258 | } | ||
| 259 | |||
| 260 | /** | ||
| 261 | * <!-- begin-user-doc --> | ||
| 262 | * <!-- end-user-doc --> | ||
| 263 | * @generated | ||
| 264 | */ | ||
| 265 | @Override | ||
| 266 | public void eSet(int featureID, Object newValue) | ||
| 267 | { | ||
| 268 | switch (featureID) | ||
| 269 | { | ||
| 270 | case SolverLanguagePackage.METRIC_DEFINITION__HEAD: | ||
| 271 | setHead((Expression)newValue); | ||
| 272 | return; | ||
| 273 | case SolverLanguagePackage.METRIC_DEFINITION__BODY: | ||
| 274 | setBody((Expression)newValue); | ||
| 275 | return; | ||
| 276 | case SolverLanguagePackage.METRIC_DEFINITION__TYPE: | ||
| 277 | setType((MetricType)newValue); | ||
| 278 | return; | ||
| 279 | } | ||
| 280 | super.eSet(featureID, newValue); | ||
| 281 | } | ||
| 282 | |||
| 283 | /** | ||
| 284 | * <!-- begin-user-doc --> | ||
| 285 | * <!-- end-user-doc --> | ||
| 286 | * @generated | ||
| 287 | */ | ||
| 288 | @Override | ||
| 289 | public void eUnset(int featureID) | ||
| 290 | { | ||
| 291 | switch (featureID) | ||
| 292 | { | ||
| 293 | case SolverLanguagePackage.METRIC_DEFINITION__HEAD: | ||
| 294 | setHead((Expression)null); | ||
| 295 | return; | ||
| 296 | case SolverLanguagePackage.METRIC_DEFINITION__BODY: | ||
| 297 | setBody((Expression)null); | ||
| 298 | return; | ||
| 299 | case SolverLanguagePackage.METRIC_DEFINITION__TYPE: | ||
| 300 | setType(TYPE_EDEFAULT); | ||
| 301 | return; | ||
| 302 | } | ||
| 303 | super.eUnset(featureID); | ||
| 304 | } | ||
| 305 | |||
| 306 | /** | ||
| 307 | * <!-- begin-user-doc --> | ||
| 308 | * <!-- end-user-doc --> | ||
| 309 | * @generated | ||
| 310 | */ | ||
| 311 | @Override | ||
| 312 | public boolean eIsSet(int featureID) | ||
| 313 | { | ||
| 314 | switch (featureID) | ||
| 315 | { | ||
| 316 | case SolverLanguagePackage.METRIC_DEFINITION__HEAD: | ||
| 317 | return head != null; | ||
| 318 | case SolverLanguagePackage.METRIC_DEFINITION__BODY: | ||
| 319 | return body != null; | ||
| 320 | case SolverLanguagePackage.METRIC_DEFINITION__TYPE: | ||
| 321 | return type != TYPE_EDEFAULT; | ||
| 322 | } | ||
| 323 | return super.eIsSet(featureID); | ||
| 324 | } | ||
| 325 | |||
| 326 | /** | ||
| 327 | * <!-- begin-user-doc --> | ||
| 328 | * <!-- end-user-doc --> | ||
| 329 | * @generated | ||
| 330 | */ | ||
| 331 | @Override | ||
| 332 | public String toString() | ||
| 333 | { | ||
| 334 | if (eIsProxy()) return super.toString(); | ||
| 335 | |||
| 336 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 337 | result.append(" (type: "); | ||
| 338 | result.append(type); | ||
| 339 | result.append(')'); | ||
| 340 | return result.toString(); | ||
| 341 | } | ||
| 342 | |||
| 343 | } //MetricDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java deleted file mode 100644 index a346568c..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java +++ /dev/null | |||
| @@ -1,296 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 12 | |||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 15 | |||
| 16 | /** | ||
| 17 | * <!-- begin-user-doc --> | ||
| 18 | * An implementation of the model object '<em><b>Multiplicity Definition</b></em>'. | ||
| 19 | * <!-- end-user-doc --> | ||
| 20 | * <p> | ||
| 21 | * The following features are implemented: | ||
| 22 | * </p> | ||
| 23 | * <ul> | ||
| 24 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getLower <em>Lower</em>}</li> | ||
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getUpper <em>Upper</em>}</li> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#isUnlimitedUpper <em>Unlimited Upper</em>}</li> | ||
| 27 | * </ul> | ||
| 28 | * | ||
| 29 | * @generated | ||
| 30 | */ | ||
| 31 | public class MultiplicityDefinitionImpl extends MinimalEObjectImpl.Container implements MultiplicityDefinition | ||
| 32 | { | ||
| 33 | /** | ||
| 34 | * The default value of the '{@link #getLower() <em>Lower</em>}' attribute. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #getLower() | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | protected static final int LOWER_EDEFAULT = 0; | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The cached value of the '{@link #getLower() <em>Lower</em>}' attribute. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #getLower() | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | protected int lower = LOWER_EDEFAULT; | ||
| 52 | |||
| 53 | /** | ||
| 54 | * The default value of the '{@link #getUpper() <em>Upper</em>}' attribute. | ||
| 55 | * <!-- begin-user-doc --> | ||
| 56 | * <!-- end-user-doc --> | ||
| 57 | * @see #getUpper() | ||
| 58 | * @generated | ||
| 59 | * @ordered | ||
| 60 | */ | ||
| 61 | protected static final int UPPER_EDEFAULT = 0; | ||
| 62 | |||
| 63 | /** | ||
| 64 | * The cached value of the '{@link #getUpper() <em>Upper</em>}' attribute. | ||
| 65 | * <!-- begin-user-doc --> | ||
| 66 | * <!-- end-user-doc --> | ||
| 67 | * @see #getUpper() | ||
| 68 | * @generated | ||
| 69 | * @ordered | ||
| 70 | */ | ||
| 71 | protected int upper = UPPER_EDEFAULT; | ||
| 72 | |||
| 73 | /** | ||
| 74 | * The default value of the '{@link #isUnlimitedUpper() <em>Unlimited Upper</em>}' attribute. | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @see #isUnlimitedUpper() | ||
| 78 | * @generated | ||
| 79 | * @ordered | ||
| 80 | */ | ||
| 81 | protected static final boolean UNLIMITED_UPPER_EDEFAULT = false; | ||
| 82 | |||
| 83 | /** | ||
| 84 | * The cached value of the '{@link #isUnlimitedUpper() <em>Unlimited Upper</em>}' attribute. | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @see #isUnlimitedUpper() | ||
| 88 | * @generated | ||
| 89 | * @ordered | ||
| 90 | */ | ||
| 91 | protected boolean unlimitedUpper = UNLIMITED_UPPER_EDEFAULT; | ||
| 92 | |||
| 93 | /** | ||
| 94 | * <!-- begin-user-doc --> | ||
| 95 | * <!-- end-user-doc --> | ||
| 96 | * @generated | ||
| 97 | */ | ||
| 98 | protected MultiplicityDefinitionImpl() | ||
| 99 | { | ||
| 100 | super(); | ||
| 101 | } | ||
| 102 | |||
| 103 | /** | ||
| 104 | * <!-- begin-user-doc --> | ||
| 105 | * <!-- end-user-doc --> | ||
| 106 | * @generated | ||
| 107 | */ | ||
| 108 | @Override | ||
| 109 | protected EClass eStaticClass() | ||
| 110 | { | ||
| 111 | return SolverLanguagePackage.Literals.MULTIPLICITY_DEFINITION; | ||
| 112 | } | ||
| 113 | |||
| 114 | /** | ||
| 115 | * <!-- begin-user-doc --> | ||
| 116 | * <!-- end-user-doc --> | ||
| 117 | * @generated | ||
| 118 | */ | ||
| 119 | @Override | ||
| 120 | public int getLower() | ||
| 121 | { | ||
| 122 | return lower; | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void setLower(int newLower) | ||
| 132 | { | ||
| 133 | int oldLower = lower; | ||
| 134 | lower = newLower; | ||
| 135 | if (eNotificationRequired()) | ||
| 136 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER, oldLower, lower)); | ||
| 137 | } | ||
| 138 | |||
| 139 | /** | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @generated | ||
| 143 | */ | ||
| 144 | @Override | ||
| 145 | public int getUpper() | ||
| 146 | { | ||
| 147 | return upper; | ||
| 148 | } | ||
| 149 | |||
| 150 | /** | ||
| 151 | * <!-- begin-user-doc --> | ||
| 152 | * <!-- end-user-doc --> | ||
| 153 | * @generated | ||
| 154 | */ | ||
| 155 | @Override | ||
| 156 | public void setUpper(int newUpper) | ||
| 157 | { | ||
| 158 | int oldUpper = upper; | ||
| 159 | upper = newUpper; | ||
| 160 | if (eNotificationRequired()) | ||
| 161 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER, oldUpper, upper)); | ||
| 162 | } | ||
| 163 | |||
| 164 | /** | ||
| 165 | * <!-- begin-user-doc --> | ||
| 166 | * <!-- end-user-doc --> | ||
| 167 | * @generated | ||
| 168 | */ | ||
| 169 | @Override | ||
| 170 | public boolean isUnlimitedUpper() | ||
| 171 | { | ||
| 172 | return unlimitedUpper; | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | @Override | ||
| 181 | public void setUnlimitedUpper(boolean newUnlimitedUpper) | ||
| 182 | { | ||
| 183 | boolean oldUnlimitedUpper = unlimitedUpper; | ||
| 184 | unlimitedUpper = newUnlimitedUpper; | ||
| 185 | if (eNotificationRequired()) | ||
| 186 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER, oldUnlimitedUpper, unlimitedUpper)); | ||
| 187 | } | ||
| 188 | |||
| 189 | /** | ||
| 190 | * <!-- begin-user-doc --> | ||
| 191 | * <!-- end-user-doc --> | ||
| 192 | * @generated | ||
| 193 | */ | ||
| 194 | @Override | ||
| 195 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 196 | { | ||
| 197 | switch (featureID) | ||
| 198 | { | ||
| 199 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: | ||
| 200 | return getLower(); | ||
| 201 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: | ||
| 202 | return getUpper(); | ||
| 203 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: | ||
| 204 | return isUnlimitedUpper(); | ||
| 205 | } | ||
| 206 | return super.eGet(featureID, resolve, coreType); | ||
| 207 | } | ||
| 208 | |||
| 209 | /** | ||
| 210 | * <!-- begin-user-doc --> | ||
| 211 | * <!-- end-user-doc --> | ||
| 212 | * @generated | ||
| 213 | */ | ||
| 214 | @Override | ||
| 215 | public void eSet(int featureID, Object newValue) | ||
| 216 | { | ||
| 217 | switch (featureID) | ||
| 218 | { | ||
| 219 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: | ||
| 220 | setLower((Integer)newValue); | ||
| 221 | return; | ||
| 222 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: | ||
| 223 | setUpper((Integer)newValue); | ||
| 224 | return; | ||
| 225 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: | ||
| 226 | setUnlimitedUpper((Boolean)newValue); | ||
| 227 | return; | ||
| 228 | } | ||
| 229 | super.eSet(featureID, newValue); | ||
| 230 | } | ||
| 231 | |||
| 232 | /** | ||
| 233 | * <!-- begin-user-doc --> | ||
| 234 | * <!-- end-user-doc --> | ||
| 235 | * @generated | ||
| 236 | */ | ||
| 237 | @Override | ||
| 238 | public void eUnset(int featureID) | ||
| 239 | { | ||
| 240 | switch (featureID) | ||
| 241 | { | ||
| 242 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: | ||
| 243 | setLower(LOWER_EDEFAULT); | ||
| 244 | return; | ||
| 245 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: | ||
| 246 | setUpper(UPPER_EDEFAULT); | ||
| 247 | return; | ||
| 248 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: | ||
| 249 | setUnlimitedUpper(UNLIMITED_UPPER_EDEFAULT); | ||
| 250 | return; | ||
| 251 | } | ||
| 252 | super.eUnset(featureID); | ||
| 253 | } | ||
| 254 | |||
| 255 | /** | ||
| 256 | * <!-- begin-user-doc --> | ||
| 257 | * <!-- end-user-doc --> | ||
| 258 | * @generated | ||
| 259 | */ | ||
| 260 | @Override | ||
| 261 | public boolean eIsSet(int featureID) | ||
| 262 | { | ||
| 263 | switch (featureID) | ||
| 264 | { | ||
| 265 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: | ||
| 266 | return lower != LOWER_EDEFAULT; | ||
| 267 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: | ||
| 268 | return upper != UPPER_EDEFAULT; | ||
| 269 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: | ||
| 270 | return unlimitedUpper != UNLIMITED_UPPER_EDEFAULT; | ||
| 271 | } | ||
| 272 | return super.eIsSet(featureID); | ||
| 273 | } | ||
| 274 | |||
| 275 | /** | ||
| 276 | * <!-- begin-user-doc --> | ||
| 277 | * <!-- end-user-doc --> | ||
| 278 | * @generated | ||
| 279 | */ | ||
| 280 | @Override | ||
| 281 | public String toString() | ||
| 282 | { | ||
| 283 | if (eIsProxy()) return super.toString(); | ||
| 284 | |||
| 285 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 286 | result.append(" (lower: "); | ||
| 287 | result.append(lower); | ||
| 288 | result.append(", upper: "); | ||
| 289 | result.append(upper); | ||
| 290 | result.append(", unlimitedUpper: "); | ||
| 291 | result.append(unlimitedUpper); | ||
| 292 | result.append(')'); | ||
| 293 | return result.toString(); | ||
| 294 | } | ||
| 295 | |||
| 296 | } //MultiplicityDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityImpl.java index 98136f79..935cf5be 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -7,24 +7,24 @@ import org.eclipse.emf.ecore.EClass; | |||
| 7 | 7 | ||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; |
| 9 | 9 | ||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | 10 | import org.eclipse.viatra.solver.language.solverLanguage.Multiplicity; |
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 12 | 12 | ||
| 13 | /** | 13 | /** |
| 14 | * <!-- begin-user-doc --> | 14 | * <!-- begin-user-doc --> |
| 15 | * An implementation of the model object '<em><b>Closure Type</b></em>'. | 15 | * An implementation of the model object '<em><b>Multiplicity</b></em>'. |
| 16 | * <!-- end-user-doc --> | 16 | * <!-- end-user-doc --> |
| 17 | * | 17 | * |
| 18 | * @generated | 18 | * @generated |
| 19 | */ | 19 | */ |
| 20 | public class ClosureTypeImpl extends MinimalEObjectImpl.Container implements ClosureType | 20 | public class MultiplicityImpl extends MinimalEObjectImpl.Container implements Multiplicity |
| 21 | { | 21 | { |
| 22 | /** | 22 | /** |
| 23 | * <!-- begin-user-doc --> | 23 | * <!-- begin-user-doc --> |
| 24 | * <!-- end-user-doc --> | 24 | * <!-- end-user-doc --> |
| 25 | * @generated | 25 | * @generated |
| 26 | */ | 26 | */ |
| 27 | protected ClosureTypeImpl() | 27 | protected MultiplicityImpl() |
| 28 | { | 28 | { |
| 29 | super(); | 29 | super(); |
| 30 | } | 30 | } |
| @@ -37,7 +37,7 @@ public class ClosureTypeImpl extends MinimalEObjectImpl.Container implements Clo | |||
| 37 | @Override | 37 | @Override |
| 38 | protected EClass eStaticClass() | 38 | protected EClass eStaticClass() |
| 39 | { | 39 | { |
| 40 | return SolverLanguagePackage.Literals.CLOSURE_TYPE; | 40 | return SolverLanguagePackage.Literals.MULTIPLICITY; |
| 41 | } | 41 | } |
| 42 | 42 | ||
| 43 | } //ClosureTypeImpl | 43 | } //MultiplicityImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedElementImpl.java index 9d907661..a94f9894 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedElementImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -8,24 +8,25 @@ import org.eclipse.emf.common.notify.Notification; | |||
| 8 | import org.eclipse.emf.ecore.EClass; | 8 | import org.eclipse.emf.ecore.EClass; |
| 9 | 9 | ||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 11 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 11 | 12 | ||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; |
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 14 | 15 | ||
| 15 | /** | 16 | /** |
| 16 | * <!-- begin-user-doc --> | 17 | * <!-- begin-user-doc --> |
| 17 | * An implementation of the model object '<em><b>Named Object</b></em>'. | 18 | * An implementation of the model object '<em><b>Named Element</b></em>'. |
| 18 | * <!-- end-user-doc --> | 19 | * <!-- end-user-doc --> |
| 19 | * <p> | 20 | * <p> |
| 20 | * The following features are implemented: | 21 | * The following features are implemented: |
| 21 | * </p> | 22 | * </p> |
| 22 | * <ul> | 23 | * <ul> |
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl#getName <em>Name</em>}</li> | 24 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedElementImpl#getName <em>Name</em>}</li> |
| 24 | * </ul> | 25 | * </ul> |
| 25 | * | 26 | * |
| 26 | * @generated | 27 | * @generated |
| 27 | */ | 28 | */ |
| 28 | public class NamedObjectImpl extends ObjectImpl implements NamedObject | 29 | public class NamedElementImpl extends MinimalEObjectImpl.Container implements NamedElement |
| 29 | { | 30 | { |
| 30 | /** | 31 | /** |
| 31 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | 32 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. |
| @@ -52,7 +53,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 52 | * <!-- end-user-doc --> | 53 | * <!-- end-user-doc --> |
| 53 | * @generated | 54 | * @generated |
| 54 | */ | 55 | */ |
| 55 | protected NamedObjectImpl() | 56 | protected NamedElementImpl() |
| 56 | { | 57 | { |
| 57 | super(); | 58 | super(); |
| 58 | } | 59 | } |
| @@ -65,7 +66,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 65 | @Override | 66 | @Override |
| 66 | protected EClass eStaticClass() | 67 | protected EClass eStaticClass() |
| 67 | { | 68 | { |
| 68 | return SolverLanguagePackage.Literals.NAMED_OBJECT; | 69 | return SolverLanguagePackage.Literals.NAMED_ELEMENT; |
| 69 | } | 70 | } |
| 70 | 71 | ||
| 71 | /** | 72 | /** |
| @@ -90,7 +91,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 90 | String oldName = name; | 91 | String oldName = name; |
| 91 | name = newName; | 92 | name = newName; |
| 92 | if (eNotificationRequired()) | 93 | if (eNotificationRequired()) |
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.NAMED_OBJECT__NAME, oldName, name)); | 94 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.NAMED_ELEMENT__NAME, oldName, name)); |
| 94 | } | 95 | } |
| 95 | 96 | ||
| 96 | /** | 97 | /** |
| @@ -103,7 +104,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 103 | { | 104 | { |
| 104 | switch (featureID) | 105 | switch (featureID) |
| 105 | { | 106 | { |
| 106 | case SolverLanguagePackage.NAMED_OBJECT__NAME: | 107 | case SolverLanguagePackage.NAMED_ELEMENT__NAME: |
| 107 | return getName(); | 108 | return getName(); |
| 108 | } | 109 | } |
| 109 | return super.eGet(featureID, resolve, coreType); | 110 | return super.eGet(featureID, resolve, coreType); |
| @@ -119,7 +120,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 119 | { | 120 | { |
| 120 | switch (featureID) | 121 | switch (featureID) |
| 121 | { | 122 | { |
| 122 | case SolverLanguagePackage.NAMED_OBJECT__NAME: | 123 | case SolverLanguagePackage.NAMED_ELEMENT__NAME: |
| 123 | setName((String)newValue); | 124 | setName((String)newValue); |
| 124 | return; | 125 | return; |
| 125 | } | 126 | } |
| @@ -136,7 +137,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 136 | { | 137 | { |
| 137 | switch (featureID) | 138 | switch (featureID) |
| 138 | { | 139 | { |
| 139 | case SolverLanguagePackage.NAMED_OBJECT__NAME: | 140 | case SolverLanguagePackage.NAMED_ELEMENT__NAME: |
| 140 | setName(NAME_EDEFAULT); | 141 | setName(NAME_EDEFAULT); |
| 141 | return; | 142 | return; |
| 142 | } | 143 | } |
| @@ -153,7 +154,7 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 153 | { | 154 | { |
| 154 | switch (featureID) | 155 | switch (featureID) |
| 155 | { | 156 | { |
| 156 | case SolverLanguagePackage.NAMED_OBJECT__NAME: | 157 | case SolverLanguagePackage.NAMED_ELEMENT__NAME: |
| 157 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | 158 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); |
| 158 | } | 159 | } |
| 159 | return super.eIsSet(featureID); | 160 | return super.eIsSet(featureID); |
| @@ -176,4 +177,4 @@ public class NamedObjectImpl extends ObjectImpl implements NamedObject | |||
| 176 | return result.toString(); | 177 | return result.toString(); |
| 177 | } | 178 | } |
| 178 | 179 | ||
| 179 | } //NamedObjectImpl | 180 | } //NamedElementImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NumericLiteralImpl.java index bc32a9a6..04622dfb 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NumericLiteralImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -11,23 +11,23 @@ import org.eclipse.emf.ecore.EClass; | |||
| 11 | 11 | ||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 13 | 13 | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 16 | 16 | ||
| 17 | /** | 17 | /** |
| 18 | * <!-- begin-user-doc --> | 18 | * <!-- begin-user-doc --> |
| 19 | * An implementation of the model object '<em><b>Real Object</b></em>'. | 19 | * An implementation of the model object '<em><b>Numeric Literal</b></em>'. |
| 20 | * <!-- end-user-doc --> | 20 | * <!-- end-user-doc --> |
| 21 | * <p> | 21 | * <p> |
| 22 | * The following features are implemented: | 22 | * The following features are implemented: |
| 23 | * </p> | 23 | * </p> |
| 24 | * <ul> | 24 | * <ul> |
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl#getValue <em>Value</em>}</li> | 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NumericLiteralImpl#getValue <em>Value</em>}</li> |
| 26 | * </ul> | 26 | * </ul> |
| 27 | * | 27 | * |
| 28 | * @generated | 28 | * @generated |
| 29 | */ | 29 | */ |
| 30 | public class RealObjectImpl extends DataObjectImpl implements RealObject | 30 | public class NumericLiteralImpl extends LiteralImpl implements NumericLiteral |
| 31 | { | 31 | { |
| 32 | /** | 32 | /** |
| 33 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. | 33 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. |
| @@ -54,7 +54,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 54 | * <!-- end-user-doc --> | 54 | * <!-- end-user-doc --> |
| 55 | * @generated | 55 | * @generated |
| 56 | */ | 56 | */ |
| 57 | protected RealObjectImpl() | 57 | protected NumericLiteralImpl() |
| 58 | { | 58 | { |
| 59 | super(); | 59 | super(); |
| 60 | } | 60 | } |
| @@ -67,7 +67,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 67 | @Override | 67 | @Override |
| 68 | protected EClass eStaticClass() | 68 | protected EClass eStaticClass() |
| 69 | { | 69 | { |
| 70 | return SolverLanguagePackage.Literals.REAL_OBJECT; | 70 | return SolverLanguagePackage.Literals.NUMERIC_LITERAL; |
| 71 | } | 71 | } |
| 72 | 72 | ||
| 73 | /** | 73 | /** |
| @@ -92,7 +92,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 92 | BigDecimal oldValue = value; | 92 | BigDecimal oldValue = value; |
| 93 | value = newValue; | 93 | value = newValue; |
| 94 | if (eNotificationRequired()) | 94 | if (eNotificationRequired()) |
| 95 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.REAL_OBJECT__VALUE, oldValue, value)); | 95 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.NUMERIC_LITERAL__VALUE, oldValue, value)); |
| 96 | } | 96 | } |
| 97 | 97 | ||
| 98 | /** | 98 | /** |
| @@ -105,7 +105,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 105 | { | 105 | { |
| 106 | switch (featureID) | 106 | switch (featureID) |
| 107 | { | 107 | { |
| 108 | case SolverLanguagePackage.REAL_OBJECT__VALUE: | 108 | case SolverLanguagePackage.NUMERIC_LITERAL__VALUE: |
| 109 | return getValue(); | 109 | return getValue(); |
| 110 | } | 110 | } |
| 111 | return super.eGet(featureID, resolve, coreType); | 111 | return super.eGet(featureID, resolve, coreType); |
| @@ -121,7 +121,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 121 | { | 121 | { |
| 122 | switch (featureID) | 122 | switch (featureID) |
| 123 | { | 123 | { |
| 124 | case SolverLanguagePackage.REAL_OBJECT__VALUE: | 124 | case SolverLanguagePackage.NUMERIC_LITERAL__VALUE: |
| 125 | setValue((BigDecimal)newValue); | 125 | setValue((BigDecimal)newValue); |
| 126 | return; | 126 | return; |
| 127 | } | 127 | } |
| @@ -138,7 +138,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 138 | { | 138 | { |
| 139 | switch (featureID) | 139 | switch (featureID) |
| 140 | { | 140 | { |
| 141 | case SolverLanguagePackage.REAL_OBJECT__VALUE: | 141 | case SolverLanguagePackage.NUMERIC_LITERAL__VALUE: |
| 142 | setValue(VALUE_EDEFAULT); | 142 | setValue(VALUE_EDEFAULT); |
| 143 | return; | 143 | return; |
| 144 | } | 144 | } |
| @@ -155,7 +155,7 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 155 | { | 155 | { |
| 156 | switch (featureID) | 156 | switch (featureID) |
| 157 | { | 157 | { |
| 158 | case SolverLanguagePackage.REAL_OBJECT__VALUE: | 158 | case SolverLanguagePackage.NUMERIC_LITERAL__VALUE: |
| 159 | return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); | 159 | return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); |
| 160 | } | 160 | } |
| 161 | return super.eIsSet(featureID); | 161 | return super.eIsSet(featureID); |
| @@ -178,4 +178,4 @@ public class RealObjectImpl extends DataObjectImpl implements RealObject | |||
| 178 | return result.toString(); | 178 | return result.toString(); |
| 179 | } | 179 | } |
| 180 | 180 | ||
| 181 | } //RealObjectImpl | 181 | } //NumericLiteralImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java deleted file mode 100644 index d2f9b8d9..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java +++ /dev/null | |||
| @@ -1,40 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 9 | |||
| 10 | /** | ||
| 11 | * <!-- begin-user-doc --> | ||
| 12 | * An implementation of the model object '<em><b>Object</b></em>'. | ||
| 13 | * <!-- end-user-doc --> | ||
| 14 | * | ||
| 15 | * @generated | ||
| 16 | */ | ||
| 17 | public class ObjectImpl extends ComplexObjectImpl implements org.eclipse.viatra.solver.language.solverLanguage.Object | ||
| 18 | { | ||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * @generated | ||
| 23 | */ | ||
| 24 | protected ObjectImpl() | ||
| 25 | { | ||
| 26 | super(); | ||
| 27 | } | ||
| 28 | |||
| 29 | /** | ||
| 30 | * <!-- begin-user-doc --> | ||
| 31 | * <!-- end-user-doc --> | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | @Override | ||
| 35 | protected EClass eStaticClass() | ||
| 36 | { | ||
| 37 | return SolverLanguagePackage.Literals.OBJECT; | ||
| 38 | } | ||
| 39 | |||
| 40 | } //ObjectImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectiveDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectiveDefinitionImpl.java new file mode 100644 index 00000000..43b16e31 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectiveDefinitionImpl.java | |||
| @@ -0,0 +1,270 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Objective Definition</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl#getKind <em>Kind</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectiveDefinitionImpl#getObjective <em>Objective</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class ObjectiveDefinitionImpl extends StatementImpl implements ObjectiveDefinition | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The default value of the '{@link #getKind() <em>Kind</em>}' attribute. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getKind() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected static final ObjectiveKind KIND_EDEFAULT = ObjectiveKind.MINIMIZE; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getKind() <em>Kind</em>}' attribute. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getKind() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected ObjectiveKind kind = KIND_EDEFAULT; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #getObjective() <em>Objective</em>}' containment reference. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #getObjective() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected Expression objective; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | protected ObjectiveDefinitionImpl() | ||
| 71 | { | ||
| 72 | super(); | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | protected EClass eStaticClass() | ||
| 82 | { | ||
| 83 | return SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | public ObjectiveKind getKind() | ||
| 93 | { | ||
| 94 | return kind; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public void setKind(ObjectiveKind newKind) | ||
| 104 | { | ||
| 105 | ObjectiveKind oldKind = kind; | ||
| 106 | kind = newKind == null ? KIND_EDEFAULT : newKind; | ||
| 107 | if (eNotificationRequired()) | ||
| 108 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.OBJECTIVE_DEFINITION__KIND, oldKind, kind)); | ||
| 109 | } | ||
| 110 | |||
| 111 | /** | ||
| 112 | * <!-- begin-user-doc --> | ||
| 113 | * <!-- end-user-doc --> | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | @Override | ||
| 117 | public Expression getObjective() | ||
| 118 | { | ||
| 119 | return objective; | ||
| 120 | } | ||
| 121 | |||
| 122 | /** | ||
| 123 | * <!-- begin-user-doc --> | ||
| 124 | * <!-- end-user-doc --> | ||
| 125 | * @generated | ||
| 126 | */ | ||
| 127 | public NotificationChain basicSetObjective(Expression newObjective, NotificationChain msgs) | ||
| 128 | { | ||
| 129 | Expression oldObjective = objective; | ||
| 130 | objective = newObjective; | ||
| 131 | if (eNotificationRequired()) | ||
| 132 | { | ||
| 133 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE, oldObjective, newObjective); | ||
| 134 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 135 | } | ||
| 136 | return msgs; | ||
| 137 | } | ||
| 138 | |||
| 139 | /** | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @generated | ||
| 143 | */ | ||
| 144 | @Override | ||
| 145 | public void setObjective(Expression newObjective) | ||
| 146 | { | ||
| 147 | if (newObjective != objective) | ||
| 148 | { | ||
| 149 | NotificationChain msgs = null; | ||
| 150 | if (objective != null) | ||
| 151 | msgs = ((InternalEObject)objective).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE, null, msgs); | ||
| 152 | if (newObjective != null) | ||
| 153 | msgs = ((InternalEObject)newObjective).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE, null, msgs); | ||
| 154 | msgs = basicSetObjective(newObjective, msgs); | ||
| 155 | if (msgs != null) msgs.dispatch(); | ||
| 156 | } | ||
| 157 | else if (eNotificationRequired()) | ||
| 158 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE, newObjective, newObjective)); | ||
| 159 | } | ||
| 160 | |||
| 161 | /** | ||
| 162 | * <!-- begin-user-doc --> | ||
| 163 | * <!-- end-user-doc --> | ||
| 164 | * @generated | ||
| 165 | */ | ||
| 166 | @Override | ||
| 167 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 168 | { | ||
| 169 | switch (featureID) | ||
| 170 | { | ||
| 171 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE: | ||
| 172 | return basicSetObjective(null, msgs); | ||
| 173 | } | ||
| 174 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 175 | } | ||
| 176 | |||
| 177 | /** | ||
| 178 | * <!-- begin-user-doc --> | ||
| 179 | * <!-- end-user-doc --> | ||
| 180 | * @generated | ||
| 181 | */ | ||
| 182 | @Override | ||
| 183 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 184 | { | ||
| 185 | switch (featureID) | ||
| 186 | { | ||
| 187 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__KIND: | ||
| 188 | return getKind(); | ||
| 189 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE: | ||
| 190 | return getObjective(); | ||
| 191 | } | ||
| 192 | return super.eGet(featureID, resolve, coreType); | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * <!-- begin-user-doc --> | ||
| 197 | * <!-- end-user-doc --> | ||
| 198 | * @generated | ||
| 199 | */ | ||
| 200 | @Override | ||
| 201 | public void eSet(int featureID, Object newValue) | ||
| 202 | { | ||
| 203 | switch (featureID) | ||
| 204 | { | ||
| 205 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__KIND: | ||
| 206 | setKind((ObjectiveKind)newValue); | ||
| 207 | return; | ||
| 208 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE: | ||
| 209 | setObjective((Expression)newValue); | ||
| 210 | return; | ||
| 211 | } | ||
| 212 | super.eSet(featureID, newValue); | ||
| 213 | } | ||
| 214 | |||
| 215 | /** | ||
| 216 | * <!-- begin-user-doc --> | ||
| 217 | * <!-- end-user-doc --> | ||
| 218 | * @generated | ||
| 219 | */ | ||
| 220 | @Override | ||
| 221 | public void eUnset(int featureID) | ||
| 222 | { | ||
| 223 | switch (featureID) | ||
| 224 | { | ||
| 225 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__KIND: | ||
| 226 | setKind(KIND_EDEFAULT); | ||
| 227 | return; | ||
| 228 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE: | ||
| 229 | setObjective((Expression)null); | ||
| 230 | return; | ||
| 231 | } | ||
| 232 | super.eUnset(featureID); | ||
| 233 | } | ||
| 234 | |||
| 235 | /** | ||
| 236 | * <!-- begin-user-doc --> | ||
| 237 | * <!-- end-user-doc --> | ||
| 238 | * @generated | ||
| 239 | */ | ||
| 240 | @Override | ||
| 241 | public boolean eIsSet(int featureID) | ||
| 242 | { | ||
| 243 | switch (featureID) | ||
| 244 | { | ||
| 245 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__KIND: | ||
| 246 | return kind != KIND_EDEFAULT; | ||
| 247 | case SolverLanguagePackage.OBJECTIVE_DEFINITION__OBJECTIVE: | ||
| 248 | return objective != null; | ||
| 249 | } | ||
| 250 | return super.eIsSet(featureID); | ||
| 251 | } | ||
| 252 | |||
| 253 | /** | ||
| 254 | * <!-- begin-user-doc --> | ||
| 255 | * <!-- end-user-doc --> | ||
| 256 | * @generated | ||
| 257 | */ | ||
| 258 | @Override | ||
| 259 | public String toString() | ||
| 260 | { | ||
| 261 | if (eIsProxy()) return super.toString(); | ||
| 262 | |||
| 263 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 264 | result.append(" (kind: "); | ||
| 265 | result.append(kind); | ||
| 266 | result.append(')'); | ||
| 267 | return result.toString(); | ||
| 268 | } | ||
| 269 | |||
| 270 | } //ObjectiveDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java deleted file mode 100644 index efc2c5f5..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Partiality Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class PartialitySymbolImpl extends SymbolImpl implements PartialitySymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected PartialitySymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.PARTIALITY_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //PartialitySymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java deleted file mode 100644 index 130cfe7a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Positive</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class PositiveImpl extends PolarityImpl implements Positive | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected PositiveImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.POSITIVE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //PositiveImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateDefinitionImpl.java new file mode 100644 index 00000000..50130f01 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateDefinitionImpl.java | |||
| @@ -0,0 +1,400 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 17 | |||
| 18 | /** | ||
| 19 | * <!-- begin-user-doc --> | ||
| 20 | * An implementation of the model object '<em><b>Predicate Definition</b></em>'. | ||
| 21 | * <!-- end-user-doc --> | ||
| 22 | * <p> | ||
| 23 | * The following features are implemented: | ||
| 24 | * </p> | ||
| 25 | * <ul> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl#getHead <em>Head</em>}</li> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl#getBody <em>Body</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl#isFunctional <em>Functional</em>}</li> | ||
| 29 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateDefinitionImpl#isError <em>Error</em>}</li> | ||
| 30 | * </ul> | ||
| 31 | * | ||
| 32 | * @generated | ||
| 33 | */ | ||
| 34 | public class PredicateDefinitionImpl extends StatementImpl implements PredicateDefinition | ||
| 35 | { | ||
| 36 | /** | ||
| 37 | * The cached value of the '{@link #getHead() <em>Head</em>}' containment reference. | ||
| 38 | * <!-- begin-user-doc --> | ||
| 39 | * <!-- end-user-doc --> | ||
| 40 | * @see #getHead() | ||
| 41 | * @generated | ||
| 42 | * @ordered | ||
| 43 | */ | ||
| 44 | protected Expression head; | ||
| 45 | |||
| 46 | /** | ||
| 47 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @see #getBody() | ||
| 51 | * @generated | ||
| 52 | * @ordered | ||
| 53 | */ | ||
| 54 | protected Expression body; | ||
| 55 | |||
| 56 | /** | ||
| 57 | * The default value of the '{@link #isFunctional() <em>Functional</em>}' attribute. | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @see #isFunctional() | ||
| 61 | * @generated | ||
| 62 | * @ordered | ||
| 63 | */ | ||
| 64 | protected static final boolean FUNCTIONAL_EDEFAULT = false; | ||
| 65 | |||
| 66 | /** | ||
| 67 | * The cached value of the '{@link #isFunctional() <em>Functional</em>}' attribute. | ||
| 68 | * <!-- begin-user-doc --> | ||
| 69 | * <!-- end-user-doc --> | ||
| 70 | * @see #isFunctional() | ||
| 71 | * @generated | ||
| 72 | * @ordered | ||
| 73 | */ | ||
| 74 | protected boolean functional = FUNCTIONAL_EDEFAULT; | ||
| 75 | |||
| 76 | /** | ||
| 77 | * The default value of the '{@link #isError() <em>Error</em>}' attribute. | ||
| 78 | * <!-- begin-user-doc --> | ||
| 79 | * <!-- end-user-doc --> | ||
| 80 | * @see #isError() | ||
| 81 | * @generated | ||
| 82 | * @ordered | ||
| 83 | */ | ||
| 84 | protected static final boolean ERROR_EDEFAULT = false; | ||
| 85 | |||
| 86 | /** | ||
| 87 | * The cached value of the '{@link #isError() <em>Error</em>}' attribute. | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @see #isError() | ||
| 91 | * @generated | ||
| 92 | * @ordered | ||
| 93 | */ | ||
| 94 | protected boolean error = ERROR_EDEFAULT; | ||
| 95 | |||
| 96 | /** | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @generated | ||
| 100 | */ | ||
| 101 | protected PredicateDefinitionImpl() | ||
| 102 | { | ||
| 103 | super(); | ||
| 104 | } | ||
| 105 | |||
| 106 | /** | ||
| 107 | * <!-- begin-user-doc --> | ||
| 108 | * <!-- end-user-doc --> | ||
| 109 | * @generated | ||
| 110 | */ | ||
| 111 | @Override | ||
| 112 | protected EClass eStaticClass() | ||
| 113 | { | ||
| 114 | return SolverLanguagePackage.Literals.PREDICATE_DEFINITION; | ||
| 115 | } | ||
| 116 | |||
| 117 | /** | ||
| 118 | * <!-- begin-user-doc --> | ||
| 119 | * <!-- end-user-doc --> | ||
| 120 | * @generated | ||
| 121 | */ | ||
| 122 | @Override | ||
| 123 | public Expression getHead() | ||
| 124 | { | ||
| 125 | return head; | ||
| 126 | } | ||
| 127 | |||
| 128 | /** | ||
| 129 | * <!-- begin-user-doc --> | ||
| 130 | * <!-- end-user-doc --> | ||
| 131 | * @generated | ||
| 132 | */ | ||
| 133 | public NotificationChain basicSetHead(Expression newHead, NotificationChain msgs) | ||
| 134 | { | ||
| 135 | Expression oldHead = head; | ||
| 136 | head = newHead; | ||
| 137 | if (eNotificationRequired()) | ||
| 138 | { | ||
| 139 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__HEAD, oldHead, newHead); | ||
| 140 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 141 | } | ||
| 142 | return msgs; | ||
| 143 | } | ||
| 144 | |||
| 145 | /** | ||
| 146 | * <!-- begin-user-doc --> | ||
| 147 | * <!-- end-user-doc --> | ||
| 148 | * @generated | ||
| 149 | */ | ||
| 150 | @Override | ||
| 151 | public void setHead(Expression newHead) | ||
| 152 | { | ||
| 153 | if (newHead != head) | ||
| 154 | { | ||
| 155 | NotificationChain msgs = null; | ||
| 156 | if (head != null) | ||
| 157 | msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_DEFINITION__HEAD, null, msgs); | ||
| 158 | if (newHead != null) | ||
| 159 | msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_DEFINITION__HEAD, null, msgs); | ||
| 160 | msgs = basicSetHead(newHead, msgs); | ||
| 161 | if (msgs != null) msgs.dispatch(); | ||
| 162 | } | ||
| 163 | else if (eNotificationRequired()) | ||
| 164 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__HEAD, newHead, newHead)); | ||
| 165 | } | ||
| 166 | |||
| 167 | /** | ||
| 168 | * <!-- begin-user-doc --> | ||
| 169 | * <!-- end-user-doc --> | ||
| 170 | * @generated | ||
| 171 | */ | ||
| 172 | @Override | ||
| 173 | public Expression getBody() | ||
| 174 | { | ||
| 175 | return body; | ||
| 176 | } | ||
| 177 | |||
| 178 | /** | ||
| 179 | * <!-- begin-user-doc --> | ||
| 180 | * <!-- end-user-doc --> | ||
| 181 | * @generated | ||
| 182 | */ | ||
| 183 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 184 | { | ||
| 185 | Expression oldBody = body; | ||
| 186 | body = newBody; | ||
| 187 | if (eNotificationRequired()) | ||
| 188 | { | ||
| 189 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__BODY, oldBody, newBody); | ||
| 190 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 191 | } | ||
| 192 | return msgs; | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * <!-- begin-user-doc --> | ||
| 197 | * <!-- end-user-doc --> | ||
| 198 | * @generated | ||
| 199 | */ | ||
| 200 | @Override | ||
| 201 | public void setBody(Expression newBody) | ||
| 202 | { | ||
| 203 | if (newBody != body) | ||
| 204 | { | ||
| 205 | NotificationChain msgs = null; | ||
| 206 | if (body != null) | ||
| 207 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_DEFINITION__BODY, null, msgs); | ||
| 208 | if (newBody != null) | ||
| 209 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_DEFINITION__BODY, null, msgs); | ||
| 210 | msgs = basicSetBody(newBody, msgs); | ||
| 211 | if (msgs != null) msgs.dispatch(); | ||
| 212 | } | ||
| 213 | else if (eNotificationRequired()) | ||
| 214 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__BODY, newBody, newBody)); | ||
| 215 | } | ||
| 216 | |||
| 217 | /** | ||
| 218 | * <!-- begin-user-doc --> | ||
| 219 | * <!-- end-user-doc --> | ||
| 220 | * @generated | ||
| 221 | */ | ||
| 222 | @Override | ||
| 223 | public boolean isFunctional() | ||
| 224 | { | ||
| 225 | return functional; | ||
| 226 | } | ||
| 227 | |||
| 228 | /** | ||
| 229 | * <!-- begin-user-doc --> | ||
| 230 | * <!-- end-user-doc --> | ||
| 231 | * @generated | ||
| 232 | */ | ||
| 233 | @Override | ||
| 234 | public void setFunctional(boolean newFunctional) | ||
| 235 | { | ||
| 236 | boolean oldFunctional = functional; | ||
| 237 | functional = newFunctional; | ||
| 238 | if (eNotificationRequired()) | ||
| 239 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__FUNCTIONAL, oldFunctional, functional)); | ||
| 240 | } | ||
| 241 | |||
| 242 | /** | ||
| 243 | * <!-- begin-user-doc --> | ||
| 244 | * <!-- end-user-doc --> | ||
| 245 | * @generated | ||
| 246 | */ | ||
| 247 | @Override | ||
| 248 | public boolean isError() | ||
| 249 | { | ||
| 250 | return error; | ||
| 251 | } | ||
| 252 | |||
| 253 | /** | ||
| 254 | * <!-- begin-user-doc --> | ||
| 255 | * <!-- end-user-doc --> | ||
| 256 | * @generated | ||
| 257 | */ | ||
| 258 | @Override | ||
| 259 | public void setError(boolean newError) | ||
| 260 | { | ||
| 261 | boolean oldError = error; | ||
| 262 | error = newError; | ||
| 263 | if (eNotificationRequired()) | ||
| 264 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_DEFINITION__ERROR, oldError, error)); | ||
| 265 | } | ||
| 266 | |||
| 267 | /** | ||
| 268 | * <!-- begin-user-doc --> | ||
| 269 | * <!-- end-user-doc --> | ||
| 270 | * @generated | ||
| 271 | */ | ||
| 272 | @Override | ||
| 273 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 274 | { | ||
| 275 | switch (featureID) | ||
| 276 | { | ||
| 277 | case SolverLanguagePackage.PREDICATE_DEFINITION__HEAD: | ||
| 278 | return basicSetHead(null, msgs); | ||
| 279 | case SolverLanguagePackage.PREDICATE_DEFINITION__BODY: | ||
| 280 | return basicSetBody(null, msgs); | ||
| 281 | } | ||
| 282 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 283 | } | ||
| 284 | |||
| 285 | /** | ||
| 286 | * <!-- begin-user-doc --> | ||
| 287 | * <!-- end-user-doc --> | ||
| 288 | * @generated | ||
| 289 | */ | ||
| 290 | @Override | ||
| 291 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 292 | { | ||
| 293 | switch (featureID) | ||
| 294 | { | ||
| 295 | case SolverLanguagePackage.PREDICATE_DEFINITION__HEAD: | ||
| 296 | return getHead(); | ||
| 297 | case SolverLanguagePackage.PREDICATE_DEFINITION__BODY: | ||
| 298 | return getBody(); | ||
| 299 | case SolverLanguagePackage.PREDICATE_DEFINITION__FUNCTIONAL: | ||
| 300 | return isFunctional(); | ||
| 301 | case SolverLanguagePackage.PREDICATE_DEFINITION__ERROR: | ||
| 302 | return isError(); | ||
| 303 | } | ||
| 304 | return super.eGet(featureID, resolve, coreType); | ||
| 305 | } | ||
| 306 | |||
| 307 | /** | ||
| 308 | * <!-- begin-user-doc --> | ||
| 309 | * <!-- end-user-doc --> | ||
| 310 | * @generated | ||
| 311 | */ | ||
| 312 | @Override | ||
| 313 | public void eSet(int featureID, Object newValue) | ||
| 314 | { | ||
| 315 | switch (featureID) | ||
| 316 | { | ||
| 317 | case SolverLanguagePackage.PREDICATE_DEFINITION__HEAD: | ||
| 318 | setHead((Expression)newValue); | ||
| 319 | return; | ||
| 320 | case SolverLanguagePackage.PREDICATE_DEFINITION__BODY: | ||
| 321 | setBody((Expression)newValue); | ||
| 322 | return; | ||
| 323 | case SolverLanguagePackage.PREDICATE_DEFINITION__FUNCTIONAL: | ||
| 324 | setFunctional((Boolean)newValue); | ||
| 325 | return; | ||
| 326 | case SolverLanguagePackage.PREDICATE_DEFINITION__ERROR: | ||
| 327 | setError((Boolean)newValue); | ||
| 328 | return; | ||
| 329 | } | ||
| 330 | super.eSet(featureID, newValue); | ||
| 331 | } | ||
| 332 | |||
| 333 | /** | ||
| 334 | * <!-- begin-user-doc --> | ||
| 335 | * <!-- end-user-doc --> | ||
| 336 | * @generated | ||
| 337 | */ | ||
| 338 | @Override | ||
| 339 | public void eUnset(int featureID) | ||
| 340 | { | ||
| 341 | switch (featureID) | ||
| 342 | { | ||
| 343 | case SolverLanguagePackage.PREDICATE_DEFINITION__HEAD: | ||
| 344 | setHead((Expression)null); | ||
| 345 | return; | ||
| 346 | case SolverLanguagePackage.PREDICATE_DEFINITION__BODY: | ||
| 347 | setBody((Expression)null); | ||
| 348 | return; | ||
| 349 | case SolverLanguagePackage.PREDICATE_DEFINITION__FUNCTIONAL: | ||
| 350 | setFunctional(FUNCTIONAL_EDEFAULT); | ||
| 351 | return; | ||
| 352 | case SolverLanguagePackage.PREDICATE_DEFINITION__ERROR: | ||
| 353 | setError(ERROR_EDEFAULT); | ||
| 354 | return; | ||
| 355 | } | ||
| 356 | super.eUnset(featureID); | ||
| 357 | } | ||
| 358 | |||
| 359 | /** | ||
| 360 | * <!-- begin-user-doc --> | ||
| 361 | * <!-- end-user-doc --> | ||
| 362 | * @generated | ||
| 363 | */ | ||
| 364 | @Override | ||
| 365 | public boolean eIsSet(int featureID) | ||
| 366 | { | ||
| 367 | switch (featureID) | ||
| 368 | { | ||
| 369 | case SolverLanguagePackage.PREDICATE_DEFINITION__HEAD: | ||
| 370 | return head != null; | ||
| 371 | case SolverLanguagePackage.PREDICATE_DEFINITION__BODY: | ||
| 372 | return body != null; | ||
| 373 | case SolverLanguagePackage.PREDICATE_DEFINITION__FUNCTIONAL: | ||
| 374 | return functional != FUNCTIONAL_EDEFAULT; | ||
| 375 | case SolverLanguagePackage.PREDICATE_DEFINITION__ERROR: | ||
| 376 | return error != ERROR_EDEFAULT; | ||
| 377 | } | ||
| 378 | return super.eIsSet(featureID); | ||
| 379 | } | ||
| 380 | |||
| 381 | /** | ||
| 382 | * <!-- begin-user-doc --> | ||
| 383 | * <!-- end-user-doc --> | ||
| 384 | * @generated | ||
| 385 | */ | ||
| 386 | @Override | ||
| 387 | public String toString() | ||
| 388 | { | ||
| 389 | if (eIsProxy()) return super.toString(); | ||
| 390 | |||
| 391 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 392 | result.append(" (functional: "); | ||
| 393 | result.append(functional); | ||
| 394 | result.append(", error: "); | ||
| 395 | result.append(error); | ||
| 396 | result.append(')'); | ||
| 397 | return result.toString(); | ||
| 398 | } | ||
| 399 | |||
| 400 | } //PredicateDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java deleted file mode 100644 index d3c7366d..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java +++ /dev/null | |||
| @@ -1,357 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.Notification; | ||
| 9 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 10 | |||
| 11 | import org.eclipse.emf.common.util.EList; | ||
| 12 | |||
| 13 | import org.eclipse.emf.ecore.EClass; | ||
| 14 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 15 | |||
| 16 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 17 | |||
| 18 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 19 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 20 | |||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 26 | |||
| 27 | /** | ||
| 28 | * <!-- begin-user-doc --> | ||
| 29 | * An implementation of the model object '<em><b>Predicate</b></em>'. | ||
| 30 | * <!-- end-user-doc --> | ||
| 31 | * <p> | ||
| 32 | * The following features are implemented: | ||
| 33 | * </p> | ||
| 34 | * <ul> | ||
| 35 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#isIsError <em>Is Error</em>}</li> | ||
| 36 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getSymbol <em>Symbol</em>}</li> | ||
| 37 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getParameters <em>Parameters</em>}</li> | ||
| 38 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getBodies <em>Bodies</em>}</li> | ||
| 39 | * </ul> | ||
| 40 | * | ||
| 41 | * @generated | ||
| 42 | */ | ||
| 43 | public class PredicateImpl extends StatementImpl implements Predicate | ||
| 44 | { | ||
| 45 | /** | ||
| 46 | * The default value of the '{@link #isIsError() <em>Is Error</em>}' attribute. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #isIsError() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected static final boolean IS_ERROR_EDEFAULT = false; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #isIsError() <em>Is Error</em>}' attribute. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #isIsError() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected boolean isError = IS_ERROR_EDEFAULT; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference. | ||
| 67 | * <!-- begin-user-doc --> | ||
| 68 | * <!-- end-user-doc --> | ||
| 69 | * @see #getSymbol() | ||
| 70 | * @generated | ||
| 71 | * @ordered | ||
| 72 | */ | ||
| 73 | protected ModelSymbol symbol; | ||
| 74 | |||
| 75 | /** | ||
| 76 | * The cached value of the '{@link #getParameters() <em>Parameters</em>}' containment reference list. | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @see #getParameters() | ||
| 80 | * @generated | ||
| 81 | * @ordered | ||
| 82 | */ | ||
| 83 | protected EList<Parameter> parameters; | ||
| 84 | |||
| 85 | /** | ||
| 86 | * The cached value of the '{@link #getBodies() <em>Bodies</em>}' containment reference list. | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @see #getBodies() | ||
| 90 | * @generated | ||
| 91 | * @ordered | ||
| 92 | */ | ||
| 93 | protected EList<PatternBody> bodies; | ||
| 94 | |||
| 95 | /** | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @generated | ||
| 99 | */ | ||
| 100 | protected PredicateImpl() | ||
| 101 | { | ||
| 102 | super(); | ||
| 103 | } | ||
| 104 | |||
| 105 | /** | ||
| 106 | * <!-- begin-user-doc --> | ||
| 107 | * <!-- end-user-doc --> | ||
| 108 | * @generated | ||
| 109 | */ | ||
| 110 | @Override | ||
| 111 | protected EClass eStaticClass() | ||
| 112 | { | ||
| 113 | return SolverLanguagePackage.Literals.PREDICATE; | ||
| 114 | } | ||
| 115 | |||
| 116 | /** | ||
| 117 | * <!-- begin-user-doc --> | ||
| 118 | * <!-- end-user-doc --> | ||
| 119 | * @generated | ||
| 120 | */ | ||
| 121 | @Override | ||
| 122 | public boolean isIsError() | ||
| 123 | { | ||
| 124 | return isError; | ||
| 125 | } | ||
| 126 | |||
| 127 | /** | ||
| 128 | * <!-- begin-user-doc --> | ||
| 129 | * <!-- end-user-doc --> | ||
| 130 | * @generated | ||
| 131 | */ | ||
| 132 | @Override | ||
| 133 | public void setIsError(boolean newIsError) | ||
| 134 | { | ||
| 135 | boolean oldIsError = isError; | ||
| 136 | isError = newIsError; | ||
| 137 | if (eNotificationRequired()) | ||
| 138 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE__IS_ERROR, oldIsError, isError)); | ||
| 139 | } | ||
| 140 | |||
| 141 | /** | ||
| 142 | * <!-- begin-user-doc --> | ||
| 143 | * <!-- end-user-doc --> | ||
| 144 | * @generated | ||
| 145 | */ | ||
| 146 | @Override | ||
| 147 | public ModelSymbol getSymbol() | ||
| 148 | { | ||
| 149 | return symbol; | ||
| 150 | } | ||
| 151 | |||
| 152 | /** | ||
| 153 | * <!-- begin-user-doc --> | ||
| 154 | * <!-- end-user-doc --> | ||
| 155 | * @generated | ||
| 156 | */ | ||
| 157 | public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) | ||
| 158 | { | ||
| 159 | ModelSymbol oldSymbol = symbol; | ||
| 160 | symbol = newSymbol; | ||
| 161 | if (eNotificationRequired()) | ||
| 162 | { | ||
| 163 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE__SYMBOL, oldSymbol, newSymbol); | ||
| 164 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 165 | } | ||
| 166 | return msgs; | ||
| 167 | } | ||
| 168 | |||
| 169 | /** | ||
| 170 | * <!-- begin-user-doc --> | ||
| 171 | * <!-- end-user-doc --> | ||
| 172 | * @generated | ||
| 173 | */ | ||
| 174 | @Override | ||
| 175 | public void setSymbol(ModelSymbol newSymbol) | ||
| 176 | { | ||
| 177 | if (newSymbol != symbol) | ||
| 178 | { | ||
| 179 | NotificationChain msgs = null; | ||
| 180 | if (symbol != null) | ||
| 181 | msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE__SYMBOL, null, msgs); | ||
| 182 | if (newSymbol != null) | ||
| 183 | msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE__SYMBOL, null, msgs); | ||
| 184 | msgs = basicSetSymbol(newSymbol, msgs); | ||
| 185 | if (msgs != null) msgs.dispatch(); | ||
| 186 | } | ||
| 187 | else if (eNotificationRequired()) | ||
| 188 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE__SYMBOL, newSymbol, newSymbol)); | ||
| 189 | } | ||
| 190 | |||
| 191 | /** | ||
| 192 | * <!-- begin-user-doc --> | ||
| 193 | * <!-- end-user-doc --> | ||
| 194 | * @generated | ||
| 195 | */ | ||
| 196 | @Override | ||
| 197 | public EList<Parameter> getParameters() | ||
| 198 | { | ||
| 199 | if (parameters == null) | ||
| 200 | { | ||
| 201 | parameters = new EObjectContainmentEList<Parameter>(Parameter.class, this, SolverLanguagePackage.PREDICATE__PARAMETERS); | ||
| 202 | } | ||
| 203 | return parameters; | ||
| 204 | } | ||
| 205 | |||
| 206 | /** | ||
| 207 | * <!-- begin-user-doc --> | ||
| 208 | * <!-- end-user-doc --> | ||
| 209 | * @generated | ||
| 210 | */ | ||
| 211 | @Override | ||
| 212 | public EList<PatternBody> getBodies() | ||
| 213 | { | ||
| 214 | if (bodies == null) | ||
| 215 | { | ||
| 216 | bodies = new EObjectContainmentEList<PatternBody>(PatternBody.class, this, SolverLanguagePackage.PREDICATE__BODIES); | ||
| 217 | } | ||
| 218 | return bodies; | ||
| 219 | } | ||
| 220 | |||
| 221 | /** | ||
| 222 | * <!-- begin-user-doc --> | ||
| 223 | * <!-- end-user-doc --> | ||
| 224 | * @generated | ||
| 225 | */ | ||
| 226 | @Override | ||
| 227 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 228 | { | ||
| 229 | switch (featureID) | ||
| 230 | { | ||
| 231 | case SolverLanguagePackage.PREDICATE__SYMBOL: | ||
| 232 | return basicSetSymbol(null, msgs); | ||
| 233 | case SolverLanguagePackage.PREDICATE__PARAMETERS: | ||
| 234 | return ((InternalEList<?>)getParameters()).basicRemove(otherEnd, msgs); | ||
| 235 | case SolverLanguagePackage.PREDICATE__BODIES: | ||
| 236 | return ((InternalEList<?>)getBodies()).basicRemove(otherEnd, msgs); | ||
| 237 | } | ||
| 238 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 239 | } | ||
| 240 | |||
| 241 | /** | ||
| 242 | * <!-- begin-user-doc --> | ||
| 243 | * <!-- end-user-doc --> | ||
| 244 | * @generated | ||
| 245 | */ | ||
| 246 | @Override | ||
| 247 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 248 | { | ||
| 249 | switch (featureID) | ||
| 250 | { | ||
| 251 | case SolverLanguagePackage.PREDICATE__IS_ERROR: | ||
| 252 | return isIsError(); | ||
| 253 | case SolverLanguagePackage.PREDICATE__SYMBOL: | ||
| 254 | return getSymbol(); | ||
| 255 | case SolverLanguagePackage.PREDICATE__PARAMETERS: | ||
| 256 | return getParameters(); | ||
| 257 | case SolverLanguagePackage.PREDICATE__BODIES: | ||
| 258 | return getBodies(); | ||
| 259 | } | ||
| 260 | return super.eGet(featureID, resolve, coreType); | ||
| 261 | } | ||
| 262 | |||
| 263 | /** | ||
| 264 | * <!-- begin-user-doc --> | ||
| 265 | * <!-- end-user-doc --> | ||
| 266 | * @generated | ||
| 267 | */ | ||
| 268 | @SuppressWarnings("unchecked") | ||
| 269 | @Override | ||
| 270 | public void eSet(int featureID, Object newValue) | ||
| 271 | { | ||
| 272 | switch (featureID) | ||
| 273 | { | ||
| 274 | case SolverLanguagePackage.PREDICATE__IS_ERROR: | ||
| 275 | setIsError((Boolean)newValue); | ||
| 276 | return; | ||
| 277 | case SolverLanguagePackage.PREDICATE__SYMBOL: | ||
| 278 | setSymbol((ModelSymbol)newValue); | ||
| 279 | return; | ||
| 280 | case SolverLanguagePackage.PREDICATE__PARAMETERS: | ||
| 281 | getParameters().clear(); | ||
| 282 | getParameters().addAll((Collection<? extends Parameter>)newValue); | ||
| 283 | return; | ||
| 284 | case SolverLanguagePackage.PREDICATE__BODIES: | ||
| 285 | getBodies().clear(); | ||
| 286 | getBodies().addAll((Collection<? extends PatternBody>)newValue); | ||
| 287 | return; | ||
| 288 | } | ||
| 289 | super.eSet(featureID, newValue); | ||
| 290 | } | ||
| 291 | |||
| 292 | /** | ||
| 293 | * <!-- begin-user-doc --> | ||
| 294 | * <!-- end-user-doc --> | ||
| 295 | * @generated | ||
| 296 | */ | ||
| 297 | @Override | ||
| 298 | public void eUnset(int featureID) | ||
| 299 | { | ||
| 300 | switch (featureID) | ||
| 301 | { | ||
| 302 | case SolverLanguagePackage.PREDICATE__IS_ERROR: | ||
| 303 | setIsError(IS_ERROR_EDEFAULT); | ||
| 304 | return; | ||
| 305 | case SolverLanguagePackage.PREDICATE__SYMBOL: | ||
| 306 | setSymbol((ModelSymbol)null); | ||
| 307 | return; | ||
| 308 | case SolverLanguagePackage.PREDICATE__PARAMETERS: | ||
| 309 | getParameters().clear(); | ||
| 310 | return; | ||
| 311 | case SolverLanguagePackage.PREDICATE__BODIES: | ||
| 312 | getBodies().clear(); | ||
| 313 | return; | ||
| 314 | } | ||
| 315 | super.eUnset(featureID); | ||
| 316 | } | ||
| 317 | |||
| 318 | /** | ||
| 319 | * <!-- begin-user-doc --> | ||
| 320 | * <!-- end-user-doc --> | ||
| 321 | * @generated | ||
| 322 | */ | ||
| 323 | @Override | ||
| 324 | public boolean eIsSet(int featureID) | ||
| 325 | { | ||
| 326 | switch (featureID) | ||
| 327 | { | ||
| 328 | case SolverLanguagePackage.PREDICATE__IS_ERROR: | ||
| 329 | return isError != IS_ERROR_EDEFAULT; | ||
| 330 | case SolverLanguagePackage.PREDICATE__SYMBOL: | ||
| 331 | return symbol != null; | ||
| 332 | case SolverLanguagePackage.PREDICATE__PARAMETERS: | ||
| 333 | return parameters != null && !parameters.isEmpty(); | ||
| 334 | case SolverLanguagePackage.PREDICATE__BODIES: | ||
| 335 | return bodies != null && !bodies.isEmpty(); | ||
| 336 | } | ||
| 337 | return super.eIsSet(featureID); | ||
| 338 | } | ||
| 339 | |||
| 340 | /** | ||
| 341 | * <!-- begin-user-doc --> | ||
| 342 | * <!-- end-user-doc --> | ||
| 343 | * @generated | ||
| 344 | */ | ||
| 345 | @Override | ||
| 346 | public String toString() | ||
| 347 | { | ||
| 348 | if (eIsProxy()) return super.toString(); | ||
| 349 | |||
| 350 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 351 | result.append(" (isError: "); | ||
| 352 | result.append(isError); | ||
| 353 | result.append(')'); | ||
| 354 | return result.toString(); | ||
| 355 | } | ||
| 356 | |||
| 357 | } //PredicateImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java index e5cc3585..744e604d 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java deleted file mode 100644 index 8cfd0980..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Real Symbol</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class RealSymbolImpl extends DataSymbolImpl implements RealSymbol | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected RealSymbolImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.REAL_SYMBOL; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //RealSymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReferenceImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReferenceImpl.java new file mode 100644 index 00000000..be44c0e9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReferenceImpl.java | |||
| @@ -0,0 +1,175 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 10 | |||
| 11 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 12 | |||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 16 | |||
| 17 | /** | ||
| 18 | * <!-- begin-user-doc --> | ||
| 19 | * An implementation of the model object '<em><b>Reference</b></em>'. | ||
| 20 | * <!-- end-user-doc --> | ||
| 21 | * <p> | ||
| 22 | * The following features are implemented: | ||
| 23 | * </p> | ||
| 24 | * <ul> | ||
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReferenceImpl#getReferred <em>Referred</em>}</li> | ||
| 26 | * </ul> | ||
| 27 | * | ||
| 28 | * @generated | ||
| 29 | */ | ||
| 30 | public class ReferenceImpl extends ExpressionImpl implements Reference | ||
| 31 | { | ||
| 32 | /** | ||
| 33 | * The cached value of the '{@link #getReferred() <em>Referred</em>}' reference. | ||
| 34 | * <!-- begin-user-doc --> | ||
| 35 | * <!-- end-user-doc --> | ||
| 36 | * @see #getReferred() | ||
| 37 | * @generated | ||
| 38 | * @ordered | ||
| 39 | */ | ||
| 40 | protected NamedElement referred; | ||
| 41 | |||
| 42 | /** | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | protected ReferenceImpl() | ||
| 48 | { | ||
| 49 | super(); | ||
| 50 | } | ||
| 51 | |||
| 52 | /** | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @generated | ||
| 56 | */ | ||
| 57 | @Override | ||
| 58 | protected EClass eStaticClass() | ||
| 59 | { | ||
| 60 | return SolverLanguagePackage.Literals.REFERENCE; | ||
| 61 | } | ||
| 62 | |||
| 63 | /** | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | @Override | ||
| 69 | public NamedElement getReferred() | ||
| 70 | { | ||
| 71 | if (referred != null && referred.eIsProxy()) | ||
| 72 | { | ||
| 73 | InternalEObject oldReferred = (InternalEObject)referred; | ||
| 74 | referred = (NamedElement)eResolveProxy(oldReferred); | ||
| 75 | if (referred != oldReferred) | ||
| 76 | { | ||
| 77 | if (eNotificationRequired()) | ||
| 78 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.REFERENCE__REFERRED, oldReferred, referred)); | ||
| 79 | } | ||
| 80 | } | ||
| 81 | return referred; | ||
| 82 | } | ||
| 83 | |||
| 84 | /** | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @generated | ||
| 88 | */ | ||
| 89 | public NamedElement basicGetReferred() | ||
| 90 | { | ||
| 91 | return referred; | ||
| 92 | } | ||
| 93 | |||
| 94 | /** | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @generated | ||
| 98 | */ | ||
| 99 | @Override | ||
| 100 | public void setReferred(NamedElement newReferred) | ||
| 101 | { | ||
| 102 | NamedElement oldReferred = referred; | ||
| 103 | referred = newReferred; | ||
| 104 | if (eNotificationRequired()) | ||
| 105 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.REFERENCE__REFERRED, oldReferred, referred)); | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | @Override | ||
| 114 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 115 | { | ||
| 116 | switch (featureID) | ||
| 117 | { | ||
| 118 | case SolverLanguagePackage.REFERENCE__REFERRED: | ||
| 119 | if (resolve) return getReferred(); | ||
| 120 | return basicGetReferred(); | ||
| 121 | } | ||
| 122 | return super.eGet(featureID, resolve, coreType); | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void eSet(int featureID, Object newValue) | ||
| 132 | { | ||
| 133 | switch (featureID) | ||
| 134 | { | ||
| 135 | case SolverLanguagePackage.REFERENCE__REFERRED: | ||
| 136 | setReferred((NamedElement)newValue); | ||
| 137 | return; | ||
| 138 | } | ||
| 139 | super.eSet(featureID, newValue); | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public void eUnset(int featureID) | ||
| 149 | { | ||
| 150 | switch (featureID) | ||
| 151 | { | ||
| 152 | case SolverLanguagePackage.REFERENCE__REFERRED: | ||
| 153 | setReferred((NamedElement)null); | ||
| 154 | return; | ||
| 155 | } | ||
| 156 | super.eUnset(featureID); | ||
| 157 | } | ||
| 158 | |||
| 159 | /** | ||
| 160 | * <!-- begin-user-doc --> | ||
| 161 | * <!-- end-user-doc --> | ||
| 162 | * @generated | ||
| 163 | */ | ||
| 164 | @Override | ||
| 165 | public boolean eIsSet(int featureID) | ||
| 166 | { | ||
| 167 | switch (featureID) | ||
| 168 | { | ||
| 169 | case SolverLanguagePackage.REFERENCE__REFERRED: | ||
| 170 | return referred != null; | ||
| 171 | } | ||
| 172 | return super.eIsSet(featureID); | ||
| 173 | } | ||
| 174 | |||
| 175 | } //ReferenceImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java deleted file mode 100644 index 111b48cb..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>Reflexive Closure</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class ReflexiveClosureImpl extends ClosureTypeImpl implements ReflexiveClosure | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected ReflexiveClosureImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.REFLEXIVE_CLOSURE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //ReflexiveClosureImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ScopeDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ScopeDefinitionImpl.java new file mode 100644 index 00000000..be109307 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ScopeDefinitionImpl.java | |||
| @@ -0,0 +1,175 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 10 | |||
| 11 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 12 | |||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 16 | |||
| 17 | /** | ||
| 18 | * <!-- begin-user-doc --> | ||
| 19 | * An implementation of the model object '<em><b>Scope Definition</b></em>'. | ||
| 20 | * <!-- end-user-doc --> | ||
| 21 | * <p> | ||
| 22 | * The following features are implemented: | ||
| 23 | * </p> | ||
| 24 | * <ul> | ||
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ScopeDefinitionImpl#getType <em>Type</em>}</li> | ||
| 26 | * </ul> | ||
| 27 | * | ||
| 28 | * @generated | ||
| 29 | */ | ||
| 30 | public class ScopeDefinitionImpl extends StatementImpl implements ScopeDefinition | ||
| 31 | { | ||
| 32 | /** | ||
| 33 | * The cached value of the '{@link #getType() <em>Type</em>}' reference. | ||
| 34 | * <!-- begin-user-doc --> | ||
| 35 | * <!-- end-user-doc --> | ||
| 36 | * @see #getType() | ||
| 37 | * @generated | ||
| 38 | * @ordered | ||
| 39 | */ | ||
| 40 | protected NamedElement type; | ||
| 41 | |||
| 42 | /** | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | protected ScopeDefinitionImpl() | ||
| 48 | { | ||
| 49 | super(); | ||
| 50 | } | ||
| 51 | |||
| 52 | /** | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @generated | ||
| 56 | */ | ||
| 57 | @Override | ||
| 58 | protected EClass eStaticClass() | ||
| 59 | { | ||
| 60 | return SolverLanguagePackage.Literals.SCOPE_DEFINITION; | ||
| 61 | } | ||
| 62 | |||
| 63 | /** | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | @Override | ||
| 69 | public NamedElement getType() | ||
| 70 | { | ||
| 71 | if (type != null && type.eIsProxy()) | ||
| 72 | { | ||
| 73 | InternalEObject oldType = (InternalEObject)type; | ||
| 74 | type = (NamedElement)eResolveProxy(oldType); | ||
| 75 | if (type != oldType) | ||
| 76 | { | ||
| 77 | if (eNotificationRequired()) | ||
| 78 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.SCOPE_DEFINITION__TYPE, oldType, type)); | ||
| 79 | } | ||
| 80 | } | ||
| 81 | return type; | ||
| 82 | } | ||
| 83 | |||
| 84 | /** | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @generated | ||
| 88 | */ | ||
| 89 | public NamedElement basicGetType() | ||
| 90 | { | ||
| 91 | return type; | ||
| 92 | } | ||
| 93 | |||
| 94 | /** | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @generated | ||
| 98 | */ | ||
| 99 | @Override | ||
| 100 | public void setType(NamedElement newType) | ||
| 101 | { | ||
| 102 | NamedElement oldType = type; | ||
| 103 | type = newType; | ||
| 104 | if (eNotificationRequired()) | ||
| 105 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.SCOPE_DEFINITION__TYPE, oldType, type)); | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | @Override | ||
| 114 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 115 | { | ||
| 116 | switch (featureID) | ||
| 117 | { | ||
| 118 | case SolverLanguagePackage.SCOPE_DEFINITION__TYPE: | ||
| 119 | if (resolve) return getType(); | ||
| 120 | return basicGetType(); | ||
| 121 | } | ||
| 122 | return super.eGet(featureID, resolve, coreType); | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void eSet(int featureID, Object newValue) | ||
| 132 | { | ||
| 133 | switch (featureID) | ||
| 134 | { | ||
| 135 | case SolverLanguagePackage.SCOPE_DEFINITION__TYPE: | ||
| 136 | setType((NamedElement)newValue); | ||
| 137 | return; | ||
| 138 | } | ||
| 139 | super.eSet(featureID, newValue); | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public void eUnset(int featureID) | ||
| 149 | { | ||
| 150 | switch (featureID) | ||
| 151 | { | ||
| 152 | case SolverLanguagePackage.SCOPE_DEFINITION__TYPE: | ||
| 153 | setType((NamedElement)null); | ||
| 154 | return; | ||
| 155 | } | ||
| 156 | super.eUnset(featureID); | ||
| 157 | } | ||
| 158 | |||
| 159 | /** | ||
| 160 | * <!-- begin-user-doc --> | ||
| 161 | * <!-- end-user-doc --> | ||
| 162 | * @generated | ||
| 163 | */ | ||
| 164 | @Override | ||
| 165 | public boolean eIsSet(int featureID) | ||
| 166 | { | ||
| 167 | switch (featureID) | ||
| 168 | { | ||
| 169 | case SolverLanguagePackage.SCOPE_DEFINITION__TYPE: | ||
| 170 | return type != null; | ||
| 171 | } | ||
| 172 | return super.eIsSet(featureID); | ||
| 173 | } | ||
| 174 | |||
| 175 | } //ScopeDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java index 5cb1dcdc..509d7568 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java | |||
| @@ -1,9 +1,10 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | import org.eclipse.emf.ecore.EDataType; | ||
| 7 | import org.eclipse.emf.ecore.EObject; | 8 | import org.eclipse.emf.ecore.EObject; |
| 8 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
| 9 | 10 | ||
| @@ -11,58 +12,7 @@ import org.eclipse.emf.ecore.impl.EFactoryImpl; | |||
| 11 | 12 | ||
| 12 | import org.eclipse.emf.ecore.plugin.EcorePlugin; | 13 | import org.eclipse.emf.ecore.plugin.EcorePlugin; |
| 13 | 14 | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.*; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | ||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | ||
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | ||
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.DataObject; | ||
| 28 | import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; | ||
| 29 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | ||
| 30 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | ||
| 31 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | ||
| 32 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | ||
| 33 | import org.eclipse.viatra.solver.language.solverLanguage.False; | ||
| 34 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | ||
| 35 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | ||
| 36 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | ||
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | ||
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | ||
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | ||
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | ||
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 43 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | ||
| 44 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | ||
| 45 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | ||
| 46 | import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; | ||
| 47 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | ||
| 48 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | ||
| 49 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | ||
| 50 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | ||
| 51 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | ||
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | ||
| 53 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
| 54 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 55 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory; | ||
| 56 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 57 | import org.eclipse.viatra.solver.language.solverLanguage.Statement; | ||
| 58 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | ||
| 59 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | ||
| 60 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 61 | import org.eclipse.viatra.solver.language.solverLanguage.True; | ||
| 62 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | ||
| 63 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | ||
| 64 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | ||
| 65 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 66 | 16 | ||
| 67 | /** | 17 | /** |
| 68 | * <!-- begin-user-doc --> | 18 | * <!-- begin-user-doc --> |
| @@ -118,56 +68,51 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 118 | { | 68 | { |
| 119 | case SolverLanguagePackage.PROBLEM: return createProblem(); | 69 | case SolverLanguagePackage.PROBLEM: return createProblem(); |
| 120 | case SolverLanguagePackage.STATEMENT: return createStatement(); | 70 | case SolverLanguagePackage.STATEMENT: return createStatement(); |
| 121 | case SolverLanguagePackage.BOOLEAN_VALUE: return createBooleanValue(); | 71 | case SolverLanguagePackage.PREDICATE_DEFINITION: return createPredicateDefinition(); |
| 122 | case SolverLanguagePackage.TRUTH_VALUE: return createTruthValue(); | 72 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: return createUnnamedErrorPrediateDefinition(); |
| 123 | case SolverLanguagePackage.INTERPRETATION: return createInterpretation(); | 73 | case SolverLanguagePackage.DEFAULT_DEFINITION: return createDefaultDefinition(); |
| 124 | case SolverLanguagePackage.BASIC_INTERPRETATION: return createBasicInterpretation(); | 74 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: return createExternPredicateDefinition(); |
| 125 | case SolverLanguagePackage.SYMBOL: return createSymbol(); | 75 | case SolverLanguagePackage.METRIC_DEFINITION: return createMetricDefinition(); |
| 126 | case SolverLanguagePackage.MODEL_SYMBOL: return createModelSymbol(); | 76 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: return createExternMetricDefinition(); |
| 127 | case SolverLanguagePackage.PARTIALITY_SYMBOL: return createPartialitySymbol(); | 77 | case SolverLanguagePackage.EXPRESSION: return createExpression(); |
| 128 | case SolverLanguagePackage.EXIST_SYMBOL: return createExistSymbol(); | 78 | case SolverLanguagePackage.IF_ELSE: return createIfElse(); |
| 129 | case SolverLanguagePackage.EQUALS_SYMBOL: return createEqualsSymbol(); | 79 | case SolverLanguagePackage.CASE: return createCase(); |
| 130 | case SolverLanguagePackage.DATA_SYMBOL: return createDataSymbol(); | 80 | case SolverLanguagePackage.COUNT: return createCount(); |
| 131 | case SolverLanguagePackage.BOOLEAN_SYMBOL: return createBooleanSymbol(); | 81 | case SolverLanguagePackage.AGGREGATION: return createAggregation(); |
| 132 | case SolverLanguagePackage.INTEGER_SYMBOL: return createIntegerSymbol(); | 82 | case SolverLanguagePackage.CALL: return createCall(); |
| 133 | case SolverLanguagePackage.REAL_SYMBOL: return createRealSymbol(); | 83 | case SolverLanguagePackage.ARGUMENT_LIST: return createArgumentList(); |
| 134 | case SolverLanguagePackage.STRING_SYMBOL: return createStringSymbol(); | 84 | case SolverLanguagePackage.ARGUMENT: return createArgument(); |
| 135 | case SolverLanguagePackage.COMPLEX_OBJECT: return createComplexObject(); | 85 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: return createExpressionArgument(); |
| 136 | case SolverLanguagePackage.OBJECT: return createObject(); | 86 | case SolverLanguagePackage.STAR_ARGUMENT: return createStarArgument(); |
| 137 | case SolverLanguagePackage.NAMED_OBJECT: return createNamedObject(); | 87 | case SolverLanguagePackage.TYPED_ARGUMENT: return createTypedArgument(); |
| 138 | case SolverLanguagePackage.UNNAMED_OBJECT: return createUnnamedObject(); | 88 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: return createTypedStarArgument(); |
| 139 | case SolverLanguagePackage.DATA_OBJECT: return createDataObject(); | 89 | case SolverLanguagePackage.REFERENCE: return createReference(); |
| 140 | case SolverLanguagePackage.BOOLEAN_OBJECT: return createBooleanObject(); | 90 | case SolverLanguagePackage.INTERVAL: return createInterval(); |
| 141 | case SolverLanguagePackage.INT_OBJECT: return createIntObject(); | ||
| 142 | case SolverLanguagePackage.REAL_OBJECT: return createRealObject(); | ||
| 143 | case SolverLanguagePackage.STRING_OBJECT: return createStringObject(); | ||
| 144 | case SolverLanguagePackage.PREDICATE: return createPredicate(); | ||
| 145 | case SolverLanguagePackage.PARAMETER: return createParameter(); | ||
| 146 | case SolverLanguagePackage.PATTERN_BODY: return createPatternBody(); | ||
| 147 | case SolverLanguagePackage.POLARITY: return createPolarity(); | ||
| 148 | case SolverLanguagePackage.CONSTRAINT: return createConstraint(); | ||
| 149 | case SolverLanguagePackage.CLOSURE_TYPE: return createClosureType(); | ||
| 150 | case SolverLanguagePackage.LITERAL: return createLiteral(); | 91 | case SolverLanguagePackage.LITERAL: return createLiteral(); |
| 151 | case SolverLanguagePackage.VARIABLE: return createVariable(); | 92 | case SolverLanguagePackage.LOGIC_LITERAL: return createLogicLiteral(); |
| 152 | case SolverLanguagePackage.ALL_INSTANCES: return createAllInstances(); | 93 | case SolverLanguagePackage.NUMERIC_LITERAL: return createNumericLiteral(); |
| 153 | case SolverLanguagePackage.ALL_OBJECTS: return createAllObjects(); | 94 | case SolverLanguagePackage.INFINITY_LITERAL: return createInfinityLiteral(); |
| 154 | case SolverLanguagePackage.DEFAULT_INTERPRETATION: return createDefaultInterpretation(); | 95 | case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: return createEmptyIntervalLiteral(); |
| 155 | case SolverLanguagePackage.CD_INTERPRETATION: return createCDInterpretation(); | 96 | case SolverLanguagePackage.STRING_LITERAL: return createStringLiteral(); |
| 156 | case SolverLanguagePackage.CLASS_INTERPRETATION: return createClassInterpretation(); | 97 | case SolverLanguagePackage.CLASS_DEFINITION: return createClassDefinition(); |
| 157 | case SolverLanguagePackage.ENUM_INTERPRETATION: return createEnumInterpretation(); | 98 | case SolverLanguagePackage.MEMBER_DEFINITION: return createMemberDefinition(); |
| 158 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: return createFieldRelationInterpretation(); | 99 | case SolverLanguagePackage.MULTIPLICITY: return createMultiplicity(); |
| 159 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: return createGlobalRelationInterpretation(); | 100 | case SolverLanguagePackage.MANY_MULTIPLICITY: return createManyMultiplicity(); |
| 160 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION: return createMultiplicityDefinition(); | 101 | case SolverLanguagePackage.EXACT_MULTIPLICITY: return createExactMultiplicity(); |
| 161 | case SolverLanguagePackage.BOOLEAN_TRUE: return createBooleanTrue(); | 102 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: return createBoundedMultiplicity(); |
| 162 | case SolverLanguagePackage.BOOLEAN_FALSE: return createBooleanFalse(); | 103 | case SolverLanguagePackage.SCOPE_DEFINITION: return createScopeDefinition(); |
| 163 | case SolverLanguagePackage.TRUE: return createTrue(); | 104 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: return createExactScopeDefinition(); |
| 164 | case SolverLanguagePackage.FALSE: return createFalse(); | 105 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: return createBoundedScopeDefinition(); |
| 165 | case SolverLanguagePackage.UNKNOWN: return createUnknown(); | 106 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: return createLowerBoundedScopeDefinition(); |
| 166 | case SolverLanguagePackage.ERROR: return createError(); | 107 | case SolverLanguagePackage.OBJECTIVE_DEFINITION: return createObjectiveDefinition(); |
| 167 | case SolverLanguagePackage.POSITIVE: return createPositive(); | 108 | case SolverLanguagePackage.NAMED_ELEMENT: return createNamedElement(); |
| 168 | case SolverLanguagePackage.NEGATIVE: return createNegative(); | 109 | case SolverLanguagePackage.ASSERTION: return createAssertion(); |
| 169 | case SolverLanguagePackage.REFLEXIVE_CLOSURE: return createReflexiveClosure(); | 110 | case SolverLanguagePackage.DISJUNCTION: return createDisjunction(); |
| 170 | case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: return createIrreflexiveClosure(); | 111 | case SolverLanguagePackage.SWITCH: return createSwitch(); |
| 112 | case SolverLanguagePackage.CONJUNCTION: return createConjunction(); | ||
| 113 | case SolverLanguagePackage.COMPARISON: return createComparison(); | ||
| 114 | case SolverLanguagePackage.BINARY_EXPRESSION: return createBinaryExpression(); | ||
| 115 | case SolverLanguagePackage.UNARY_EXPRESSION: return createUnaryExpression(); | ||
| 171 | default: | 116 | default: |
| 172 | throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); | 117 | throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); |
| 173 | } | 118 | } |
| @@ -179,6 +124,60 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 179 | * @generated | 124 | * @generated |
| 180 | */ | 125 | */ |
| 181 | @Override | 126 | @Override |
| 127 | public Object createFromString(EDataType eDataType, String initialValue) | ||
| 128 | { | ||
| 129 | switch (eDataType.getClassifierID()) | ||
| 130 | { | ||
| 131 | case SolverLanguagePackage.METRIC_TYPE: | ||
| 132 | return createMetricTypeFromString(eDataType, initialValue); | ||
| 133 | case SolverLanguagePackage.BINARY_OPERATOR: | ||
| 134 | return createBinaryOperatorFromString(eDataType, initialValue); | ||
| 135 | case SolverLanguagePackage.UNARY_OP: | ||
| 136 | return createUnaryOpFromString(eDataType, initialValue); | ||
| 137 | case SolverLanguagePackage.AGGREGATION_OP: | ||
| 138 | return createAggregationOpFromString(eDataType, initialValue); | ||
| 139 | case SolverLanguagePackage.LOGIC_VALUE: | ||
| 140 | return createLogicValueFromString(eDataType, initialValue); | ||
| 141 | case SolverLanguagePackage.OBJECTIVE_KIND: | ||
| 142 | return createObjectiveKindFromString(eDataType, initialValue); | ||
| 143 | default: | ||
| 144 | throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); | ||
| 145 | } | ||
| 146 | } | ||
| 147 | |||
| 148 | /** | ||
| 149 | * <!-- begin-user-doc --> | ||
| 150 | * <!-- end-user-doc --> | ||
| 151 | * @generated | ||
| 152 | */ | ||
| 153 | @Override | ||
| 154 | public String convertToString(EDataType eDataType, Object instanceValue) | ||
| 155 | { | ||
| 156 | switch (eDataType.getClassifierID()) | ||
| 157 | { | ||
| 158 | case SolverLanguagePackage.METRIC_TYPE: | ||
| 159 | return convertMetricTypeToString(eDataType, instanceValue); | ||
| 160 | case SolverLanguagePackage.BINARY_OPERATOR: | ||
| 161 | return convertBinaryOperatorToString(eDataType, instanceValue); | ||
| 162 | case SolverLanguagePackage.UNARY_OP: | ||
| 163 | return convertUnaryOpToString(eDataType, instanceValue); | ||
| 164 | case SolverLanguagePackage.AGGREGATION_OP: | ||
| 165 | return convertAggregationOpToString(eDataType, instanceValue); | ||
| 166 | case SolverLanguagePackage.LOGIC_VALUE: | ||
| 167 | return convertLogicValueToString(eDataType, instanceValue); | ||
| 168 | case SolverLanguagePackage.OBJECTIVE_KIND: | ||
| 169 | return convertObjectiveKindToString(eDataType, instanceValue); | ||
| 170 | default: | ||
| 171 | throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); | ||
| 172 | } | ||
| 173 | } | ||
| 174 | |||
| 175 | /** | ||
| 176 | * <!-- begin-user-doc --> | ||
| 177 | * <!-- end-user-doc --> | ||
| 178 | * @generated | ||
| 179 | */ | ||
| 180 | @Override | ||
| 182 | public Problem createProblem() | 181 | public Problem createProblem() |
| 183 | { | 182 | { |
| 184 | ProblemImpl problem = new ProblemImpl(); | 183 | ProblemImpl problem = new ProblemImpl(); |
| @@ -203,10 +202,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 203 | * @generated | 202 | * @generated |
| 204 | */ | 203 | */ |
| 205 | @Override | 204 | @Override |
| 206 | public BooleanValue createBooleanValue() | 205 | public PredicateDefinition createPredicateDefinition() |
| 207 | { | 206 | { |
| 208 | BooleanValueImpl booleanValue = new BooleanValueImpl(); | 207 | PredicateDefinitionImpl predicateDefinition = new PredicateDefinitionImpl(); |
| 209 | return booleanValue; | 208 | return predicateDefinition; |
| 210 | } | 209 | } |
| 211 | 210 | ||
| 212 | /** | 211 | /** |
| @@ -215,10 +214,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 215 | * @generated | 214 | * @generated |
| 216 | */ | 215 | */ |
| 217 | @Override | 216 | @Override |
| 218 | public TruthValue createTruthValue() | 217 | public UnnamedErrorPrediateDefinition createUnnamedErrorPrediateDefinition() |
| 219 | { | 218 | { |
| 220 | TruthValueImpl truthValue = new TruthValueImpl(); | 219 | UnnamedErrorPrediateDefinitionImpl unnamedErrorPrediateDefinition = new UnnamedErrorPrediateDefinitionImpl(); |
| 221 | return truthValue; | 220 | return unnamedErrorPrediateDefinition; |
| 222 | } | 221 | } |
| 223 | 222 | ||
| 224 | /** | 223 | /** |
| @@ -227,10 +226,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 227 | * @generated | 226 | * @generated |
| 228 | */ | 227 | */ |
| 229 | @Override | 228 | @Override |
| 230 | public Interpretation createInterpretation() | 229 | public DefaultDefinition createDefaultDefinition() |
| 231 | { | 230 | { |
| 232 | InterpretationImpl interpretation = new InterpretationImpl(); | 231 | DefaultDefinitionImpl defaultDefinition = new DefaultDefinitionImpl(); |
| 233 | return interpretation; | 232 | return defaultDefinition; |
| 234 | } | 233 | } |
| 235 | 234 | ||
| 236 | /** | 235 | /** |
| @@ -239,10 +238,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 239 | * @generated | 238 | * @generated |
| 240 | */ | 239 | */ |
| 241 | @Override | 240 | @Override |
| 242 | public BasicInterpretation createBasicInterpretation() | 241 | public ExternPredicateDefinition createExternPredicateDefinition() |
| 243 | { | 242 | { |
| 244 | BasicInterpretationImpl basicInterpretation = new BasicInterpretationImpl(); | 243 | ExternPredicateDefinitionImpl externPredicateDefinition = new ExternPredicateDefinitionImpl(); |
| 245 | return basicInterpretation; | 244 | return externPredicateDefinition; |
| 246 | } | 245 | } |
| 247 | 246 | ||
| 248 | /** | 247 | /** |
| @@ -251,10 +250,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 251 | * @generated | 250 | * @generated |
| 252 | */ | 251 | */ |
| 253 | @Override | 252 | @Override |
| 254 | public Symbol createSymbol() | 253 | public MetricDefinition createMetricDefinition() |
| 255 | { | 254 | { |
| 256 | SymbolImpl symbol = new SymbolImpl(); | 255 | MetricDefinitionImpl metricDefinition = new MetricDefinitionImpl(); |
| 257 | return symbol; | 256 | return metricDefinition; |
| 258 | } | 257 | } |
| 259 | 258 | ||
| 260 | /** | 259 | /** |
| @@ -263,10 +262,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 263 | * @generated | 262 | * @generated |
| 264 | */ | 263 | */ |
| 265 | @Override | 264 | @Override |
| 266 | public ModelSymbol createModelSymbol() | 265 | public ExternMetricDefinition createExternMetricDefinition() |
| 267 | { | 266 | { |
| 268 | ModelSymbolImpl modelSymbol = new ModelSymbolImpl(); | 267 | ExternMetricDefinitionImpl externMetricDefinition = new ExternMetricDefinitionImpl(); |
| 269 | return modelSymbol; | 268 | return externMetricDefinition; |
| 270 | } | 269 | } |
| 271 | 270 | ||
| 272 | /** | 271 | /** |
| @@ -275,10 +274,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 275 | * @generated | 274 | * @generated |
| 276 | */ | 275 | */ |
| 277 | @Override | 276 | @Override |
| 278 | public PartialitySymbol createPartialitySymbol() | 277 | public Expression createExpression() |
| 279 | { | 278 | { |
| 280 | PartialitySymbolImpl partialitySymbol = new PartialitySymbolImpl(); | 279 | ExpressionImpl expression = new ExpressionImpl(); |
| 281 | return partialitySymbol; | 280 | return expression; |
| 282 | } | 281 | } |
| 283 | 282 | ||
| 284 | /** | 283 | /** |
| @@ -287,10 +286,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 287 | * @generated | 286 | * @generated |
| 288 | */ | 287 | */ |
| 289 | @Override | 288 | @Override |
| 290 | public ExistSymbol createExistSymbol() | 289 | public IfElse createIfElse() |
| 291 | { | 290 | { |
| 292 | ExistSymbolImpl existSymbol = new ExistSymbolImpl(); | 291 | IfElseImpl ifElse = new IfElseImpl(); |
| 293 | return existSymbol; | 292 | return ifElse; |
| 294 | } | 293 | } |
| 295 | 294 | ||
| 296 | /** | 295 | /** |
| @@ -299,10 +298,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 299 | * @generated | 298 | * @generated |
| 300 | */ | 299 | */ |
| 301 | @Override | 300 | @Override |
| 302 | public EqualsSymbol createEqualsSymbol() | 301 | public Case createCase() |
| 303 | { | 302 | { |
| 304 | EqualsSymbolImpl equalsSymbol = new EqualsSymbolImpl(); | 303 | CaseImpl case_ = new CaseImpl(); |
| 305 | return equalsSymbol; | 304 | return case_; |
| 306 | } | 305 | } |
| 307 | 306 | ||
| 308 | /** | 307 | /** |
| @@ -311,10 +310,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 311 | * @generated | 310 | * @generated |
| 312 | */ | 311 | */ |
| 313 | @Override | 312 | @Override |
| 314 | public DataSymbol createDataSymbol() | 313 | public Count createCount() |
| 315 | { | 314 | { |
| 316 | DataSymbolImpl dataSymbol = new DataSymbolImpl(); | 315 | CountImpl count = new CountImpl(); |
| 317 | return dataSymbol; | 316 | return count; |
| 318 | } | 317 | } |
| 319 | 318 | ||
| 320 | /** | 319 | /** |
| @@ -323,10 +322,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 323 | * @generated | 322 | * @generated |
| 324 | */ | 323 | */ |
| 325 | @Override | 324 | @Override |
| 326 | public BooleanSymbol createBooleanSymbol() | 325 | public Aggregation createAggregation() |
| 327 | { | 326 | { |
| 328 | BooleanSymbolImpl booleanSymbol = new BooleanSymbolImpl(); | 327 | AggregationImpl aggregation = new AggregationImpl(); |
| 329 | return booleanSymbol; | 328 | return aggregation; |
| 330 | } | 329 | } |
| 331 | 330 | ||
| 332 | /** | 331 | /** |
| @@ -335,10 +334,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 335 | * @generated | 334 | * @generated |
| 336 | */ | 335 | */ |
| 337 | @Override | 336 | @Override |
| 338 | public IntegerSymbol createIntegerSymbol() | 337 | public Call createCall() |
| 339 | { | 338 | { |
| 340 | IntegerSymbolImpl integerSymbol = new IntegerSymbolImpl(); | 339 | CallImpl call = new CallImpl(); |
| 341 | return integerSymbol; | 340 | return call; |
| 342 | } | 341 | } |
| 343 | 342 | ||
| 344 | /** | 343 | /** |
| @@ -347,10 +346,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 347 | * @generated | 346 | * @generated |
| 348 | */ | 347 | */ |
| 349 | @Override | 348 | @Override |
| 350 | public RealSymbol createRealSymbol() | 349 | public ArgumentList createArgumentList() |
| 351 | { | 350 | { |
| 352 | RealSymbolImpl realSymbol = new RealSymbolImpl(); | 351 | ArgumentListImpl argumentList = new ArgumentListImpl(); |
| 353 | return realSymbol; | 352 | return argumentList; |
| 354 | } | 353 | } |
| 355 | 354 | ||
| 356 | /** | 355 | /** |
| @@ -359,10 +358,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 359 | * @generated | 358 | * @generated |
| 360 | */ | 359 | */ |
| 361 | @Override | 360 | @Override |
| 362 | public StringSymbol createStringSymbol() | 361 | public Argument createArgument() |
| 363 | { | 362 | { |
| 364 | StringSymbolImpl stringSymbol = new StringSymbolImpl(); | 363 | ArgumentImpl argument = new ArgumentImpl(); |
| 365 | return stringSymbol; | 364 | return argument; |
| 366 | } | 365 | } |
| 367 | 366 | ||
| 368 | /** | 367 | /** |
| @@ -371,10 +370,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 371 | * @generated | 370 | * @generated |
| 372 | */ | 371 | */ |
| 373 | @Override | 372 | @Override |
| 374 | public ComplexObject createComplexObject() | 373 | public ExpressionArgument createExpressionArgument() |
| 375 | { | 374 | { |
| 376 | ComplexObjectImpl complexObject = new ComplexObjectImpl(); | 375 | ExpressionArgumentImpl expressionArgument = new ExpressionArgumentImpl(); |
| 377 | return complexObject; | 376 | return expressionArgument; |
| 378 | } | 377 | } |
| 379 | 378 | ||
| 380 | /** | 379 | /** |
| @@ -383,10 +382,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 383 | * @generated | 382 | * @generated |
| 384 | */ | 383 | */ |
| 385 | @Override | 384 | @Override |
| 386 | public org.eclipse.viatra.solver.language.solverLanguage.Object createObject() | 385 | public StarArgument createStarArgument() |
| 387 | { | 386 | { |
| 388 | ObjectImpl object = new ObjectImpl(); | 387 | StarArgumentImpl starArgument = new StarArgumentImpl(); |
| 389 | return object; | 388 | return starArgument; |
| 390 | } | 389 | } |
| 391 | 390 | ||
| 392 | /** | 391 | /** |
| @@ -395,10 +394,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 395 | * @generated | 394 | * @generated |
| 396 | */ | 395 | */ |
| 397 | @Override | 396 | @Override |
| 398 | public NamedObject createNamedObject() | 397 | public TypedArgument createTypedArgument() |
| 399 | { | 398 | { |
| 400 | NamedObjectImpl namedObject = new NamedObjectImpl(); | 399 | TypedArgumentImpl typedArgument = new TypedArgumentImpl(); |
| 401 | return namedObject; | 400 | return typedArgument; |
| 402 | } | 401 | } |
| 403 | 402 | ||
| 404 | /** | 403 | /** |
| @@ -407,10 +406,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 407 | * @generated | 406 | * @generated |
| 408 | */ | 407 | */ |
| 409 | @Override | 408 | @Override |
| 410 | public UnnamedObject createUnnamedObject() | 409 | public TypedStarArgument createTypedStarArgument() |
| 411 | { | 410 | { |
| 412 | UnnamedObjectImpl unnamedObject = new UnnamedObjectImpl(); | 411 | TypedStarArgumentImpl typedStarArgument = new TypedStarArgumentImpl(); |
| 413 | return unnamedObject; | 412 | return typedStarArgument; |
| 414 | } | 413 | } |
| 415 | 414 | ||
| 416 | /** | 415 | /** |
| @@ -419,10 +418,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 419 | * @generated | 418 | * @generated |
| 420 | */ | 419 | */ |
| 421 | @Override | 420 | @Override |
| 422 | public DataObject createDataObject() | 421 | public Reference createReference() |
| 423 | { | 422 | { |
| 424 | DataObjectImpl dataObject = new DataObjectImpl(); | 423 | ReferenceImpl reference = new ReferenceImpl(); |
| 425 | return dataObject; | 424 | return reference; |
| 426 | } | 425 | } |
| 427 | 426 | ||
| 428 | /** | 427 | /** |
| @@ -431,10 +430,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 431 | * @generated | 430 | * @generated |
| 432 | */ | 431 | */ |
| 433 | @Override | 432 | @Override |
| 434 | public BooleanObject createBooleanObject() | 433 | public Interval createInterval() |
| 435 | { | 434 | { |
| 436 | BooleanObjectImpl booleanObject = new BooleanObjectImpl(); | 435 | IntervalImpl interval = new IntervalImpl(); |
| 437 | return booleanObject; | 436 | return interval; |
| 438 | } | 437 | } |
| 439 | 438 | ||
| 440 | /** | 439 | /** |
| @@ -443,10 +442,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 443 | * @generated | 442 | * @generated |
| 444 | */ | 443 | */ |
| 445 | @Override | 444 | @Override |
| 446 | public IntObject createIntObject() | 445 | public Literal createLiteral() |
| 447 | { | 446 | { |
| 448 | IntObjectImpl intObject = new IntObjectImpl(); | 447 | LiteralImpl literal = new LiteralImpl(); |
| 449 | return intObject; | 448 | return literal; |
| 450 | } | 449 | } |
| 451 | 450 | ||
| 452 | /** | 451 | /** |
| @@ -455,10 +454,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 455 | * @generated | 454 | * @generated |
| 456 | */ | 455 | */ |
| 457 | @Override | 456 | @Override |
| 458 | public RealObject createRealObject() | 457 | public LogicLiteral createLogicLiteral() |
| 459 | { | 458 | { |
| 460 | RealObjectImpl realObject = new RealObjectImpl(); | 459 | LogicLiteralImpl logicLiteral = new LogicLiteralImpl(); |
| 461 | return realObject; | 460 | return logicLiteral; |
| 462 | } | 461 | } |
| 463 | 462 | ||
| 464 | /** | 463 | /** |
| @@ -467,10 +466,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 467 | * @generated | 466 | * @generated |
| 468 | */ | 467 | */ |
| 469 | @Override | 468 | @Override |
| 470 | public StringObject createStringObject() | 469 | public NumericLiteral createNumericLiteral() |
| 471 | { | 470 | { |
| 472 | StringObjectImpl stringObject = new StringObjectImpl(); | 471 | NumericLiteralImpl numericLiteral = new NumericLiteralImpl(); |
| 473 | return stringObject; | 472 | return numericLiteral; |
| 474 | } | 473 | } |
| 475 | 474 | ||
| 476 | /** | 475 | /** |
| @@ -479,10 +478,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 479 | * @generated | 478 | * @generated |
| 480 | */ | 479 | */ |
| 481 | @Override | 480 | @Override |
| 482 | public Predicate createPredicate() | 481 | public InfinityLiteral createInfinityLiteral() |
| 483 | { | 482 | { |
| 484 | PredicateImpl predicate = new PredicateImpl(); | 483 | InfinityLiteralImpl infinityLiteral = new InfinityLiteralImpl(); |
| 485 | return predicate; | 484 | return infinityLiteral; |
| 486 | } | 485 | } |
| 487 | 486 | ||
| 488 | /** | 487 | /** |
| @@ -491,10 +490,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 491 | * @generated | 490 | * @generated |
| 492 | */ | 491 | */ |
| 493 | @Override | 492 | @Override |
| 494 | public Parameter createParameter() | 493 | public EmptyIntervalLiteral createEmptyIntervalLiteral() |
| 495 | { | 494 | { |
| 496 | ParameterImpl parameter = new ParameterImpl(); | 495 | EmptyIntervalLiteralImpl emptyIntervalLiteral = new EmptyIntervalLiteralImpl(); |
| 497 | return parameter; | 496 | return emptyIntervalLiteral; |
| 498 | } | 497 | } |
| 499 | 498 | ||
| 500 | /** | 499 | /** |
| @@ -503,10 +502,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 503 | * @generated | 502 | * @generated |
| 504 | */ | 503 | */ |
| 505 | @Override | 504 | @Override |
| 506 | public PatternBody createPatternBody() | 505 | public StringLiteral createStringLiteral() |
| 507 | { | 506 | { |
| 508 | PatternBodyImpl patternBody = new PatternBodyImpl(); | 507 | StringLiteralImpl stringLiteral = new StringLiteralImpl(); |
| 509 | return patternBody; | 508 | return stringLiteral; |
| 510 | } | 509 | } |
| 511 | 510 | ||
| 512 | /** | 511 | /** |
| @@ -515,10 +514,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 515 | * @generated | 514 | * @generated |
| 516 | */ | 515 | */ |
| 517 | @Override | 516 | @Override |
| 518 | public Polarity createPolarity() | 517 | public ClassDefinition createClassDefinition() |
| 519 | { | 518 | { |
| 520 | PolarityImpl polarity = new PolarityImpl(); | 519 | ClassDefinitionImpl classDefinition = new ClassDefinitionImpl(); |
| 521 | return polarity; | 520 | return classDefinition; |
| 522 | } | 521 | } |
| 523 | 522 | ||
| 524 | /** | 523 | /** |
| @@ -527,10 +526,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 527 | * @generated | 526 | * @generated |
| 528 | */ | 527 | */ |
| 529 | @Override | 528 | @Override |
| 530 | public Constraint createConstraint() | 529 | public MemberDefinition createMemberDefinition() |
| 531 | { | 530 | { |
| 532 | ConstraintImpl constraint = new ConstraintImpl(); | 531 | MemberDefinitionImpl memberDefinition = new MemberDefinitionImpl(); |
| 533 | return constraint; | 532 | return memberDefinition; |
| 534 | } | 533 | } |
| 535 | 534 | ||
| 536 | /** | 535 | /** |
| @@ -539,10 +538,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 539 | * @generated | 538 | * @generated |
| 540 | */ | 539 | */ |
| 541 | @Override | 540 | @Override |
| 542 | public ClosureType createClosureType() | 541 | public Multiplicity createMultiplicity() |
| 543 | { | 542 | { |
| 544 | ClosureTypeImpl closureType = new ClosureTypeImpl(); | 543 | MultiplicityImpl multiplicity = new MultiplicityImpl(); |
| 545 | return closureType; | 544 | return multiplicity; |
| 546 | } | 545 | } |
| 547 | 546 | ||
| 548 | /** | 547 | /** |
| @@ -551,10 +550,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 551 | * @generated | 550 | * @generated |
| 552 | */ | 551 | */ |
| 553 | @Override | 552 | @Override |
| 554 | public Literal createLiteral() | 553 | public ManyMultiplicity createManyMultiplicity() |
| 555 | { | 554 | { |
| 556 | LiteralImpl literal = new LiteralImpl(); | 555 | ManyMultiplicityImpl manyMultiplicity = new ManyMultiplicityImpl(); |
| 557 | return literal; | 556 | return manyMultiplicity; |
| 558 | } | 557 | } |
| 559 | 558 | ||
| 560 | /** | 559 | /** |
| @@ -563,10 +562,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 563 | * @generated | 562 | * @generated |
| 564 | */ | 563 | */ |
| 565 | @Override | 564 | @Override |
| 566 | public Variable createVariable() | 565 | public ExactMultiplicity createExactMultiplicity() |
| 567 | { | 566 | { |
| 568 | VariableImpl variable = new VariableImpl(); | 567 | ExactMultiplicityImpl exactMultiplicity = new ExactMultiplicityImpl(); |
| 569 | return variable; | 568 | return exactMultiplicity; |
| 570 | } | 569 | } |
| 571 | 570 | ||
| 572 | /** | 571 | /** |
| @@ -575,10 +574,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 575 | * @generated | 574 | * @generated |
| 576 | */ | 575 | */ |
| 577 | @Override | 576 | @Override |
| 578 | public AllInstances createAllInstances() | 577 | public BoundedMultiplicity createBoundedMultiplicity() |
| 579 | { | 578 | { |
| 580 | AllInstancesImpl allInstances = new AllInstancesImpl(); | 579 | BoundedMultiplicityImpl boundedMultiplicity = new BoundedMultiplicityImpl(); |
| 581 | return allInstances; | 580 | return boundedMultiplicity; |
| 582 | } | 581 | } |
| 583 | 582 | ||
| 584 | /** | 583 | /** |
| @@ -587,10 +586,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 587 | * @generated | 586 | * @generated |
| 588 | */ | 587 | */ |
| 589 | @Override | 588 | @Override |
| 590 | public AllObjects createAllObjects() | 589 | public ScopeDefinition createScopeDefinition() |
| 591 | { | 590 | { |
| 592 | AllObjectsImpl allObjects = new AllObjectsImpl(); | 591 | ScopeDefinitionImpl scopeDefinition = new ScopeDefinitionImpl(); |
| 593 | return allObjects; | 592 | return scopeDefinition; |
| 594 | } | 593 | } |
| 595 | 594 | ||
| 596 | /** | 595 | /** |
| @@ -599,10 +598,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 599 | * @generated | 598 | * @generated |
| 600 | */ | 599 | */ |
| 601 | @Override | 600 | @Override |
| 602 | public DefaultInterpretation createDefaultInterpretation() | 601 | public ExactScopeDefinition createExactScopeDefinition() |
| 603 | { | 602 | { |
| 604 | DefaultInterpretationImpl defaultInterpretation = new DefaultInterpretationImpl(); | 603 | ExactScopeDefinitionImpl exactScopeDefinition = new ExactScopeDefinitionImpl(); |
| 605 | return defaultInterpretation; | 604 | return exactScopeDefinition; |
| 606 | } | 605 | } |
| 607 | 606 | ||
| 608 | /** | 607 | /** |
| @@ -611,10 +610,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 611 | * @generated | 610 | * @generated |
| 612 | */ | 611 | */ |
| 613 | @Override | 612 | @Override |
| 614 | public CDInterpretation createCDInterpretation() | 613 | public BoundedScopeDefinition createBoundedScopeDefinition() |
| 615 | { | 614 | { |
| 616 | CDInterpretationImpl cdInterpretation = new CDInterpretationImpl(); | 615 | BoundedScopeDefinitionImpl boundedScopeDefinition = new BoundedScopeDefinitionImpl(); |
| 617 | return cdInterpretation; | 616 | return boundedScopeDefinition; |
| 618 | } | 617 | } |
| 619 | 618 | ||
| 620 | /** | 619 | /** |
| @@ -623,10 +622,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 623 | * @generated | 622 | * @generated |
| 624 | */ | 623 | */ |
| 625 | @Override | 624 | @Override |
| 626 | public ClassInterpretation createClassInterpretation() | 625 | public LowerBoundedScopeDefinition createLowerBoundedScopeDefinition() |
| 627 | { | 626 | { |
| 628 | ClassInterpretationImpl classInterpretation = new ClassInterpretationImpl(); | 627 | LowerBoundedScopeDefinitionImpl lowerBoundedScopeDefinition = new LowerBoundedScopeDefinitionImpl(); |
| 629 | return classInterpretation; | 628 | return lowerBoundedScopeDefinition; |
| 630 | } | 629 | } |
| 631 | 630 | ||
| 632 | /** | 631 | /** |
| @@ -635,10 +634,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 635 | * @generated | 634 | * @generated |
| 636 | */ | 635 | */ |
| 637 | @Override | 636 | @Override |
| 638 | public EnumInterpretation createEnumInterpretation() | 637 | public ObjectiveDefinition createObjectiveDefinition() |
| 639 | { | 638 | { |
| 640 | EnumInterpretationImpl enumInterpretation = new EnumInterpretationImpl(); | 639 | ObjectiveDefinitionImpl objectiveDefinition = new ObjectiveDefinitionImpl(); |
| 641 | return enumInterpretation; | 640 | return objectiveDefinition; |
| 642 | } | 641 | } |
| 643 | 642 | ||
| 644 | /** | 643 | /** |
| @@ -647,10 +646,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 647 | * @generated | 646 | * @generated |
| 648 | */ | 647 | */ |
| 649 | @Override | 648 | @Override |
| 650 | public FieldRelationInterpretation createFieldRelationInterpretation() | 649 | public NamedElement createNamedElement() |
| 651 | { | 650 | { |
| 652 | FieldRelationInterpretationImpl fieldRelationInterpretation = new FieldRelationInterpretationImpl(); | 651 | NamedElementImpl namedElement = new NamedElementImpl(); |
| 653 | return fieldRelationInterpretation; | 652 | return namedElement; |
| 654 | } | 653 | } |
| 655 | 654 | ||
| 656 | /** | 655 | /** |
| @@ -659,10 +658,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 659 | * @generated | 658 | * @generated |
| 660 | */ | 659 | */ |
| 661 | @Override | 660 | @Override |
| 662 | public GlobalRelationInterpretation createGlobalRelationInterpretation() | 661 | public Assertion createAssertion() |
| 663 | { | 662 | { |
| 664 | GlobalRelationInterpretationImpl globalRelationInterpretation = new GlobalRelationInterpretationImpl(); | 663 | AssertionImpl assertion = new AssertionImpl(); |
| 665 | return globalRelationInterpretation; | 664 | return assertion; |
| 666 | } | 665 | } |
| 667 | 666 | ||
| 668 | /** | 667 | /** |
| @@ -671,10 +670,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 671 | * @generated | 670 | * @generated |
| 672 | */ | 671 | */ |
| 673 | @Override | 672 | @Override |
| 674 | public MultiplicityDefinition createMultiplicityDefinition() | 673 | public Disjunction createDisjunction() |
| 675 | { | 674 | { |
| 676 | MultiplicityDefinitionImpl multiplicityDefinition = new MultiplicityDefinitionImpl(); | 675 | DisjunctionImpl disjunction = new DisjunctionImpl(); |
| 677 | return multiplicityDefinition; | 676 | return disjunction; |
| 678 | } | 677 | } |
| 679 | 678 | ||
| 680 | /** | 679 | /** |
| @@ -683,10 +682,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 683 | * @generated | 682 | * @generated |
| 684 | */ | 683 | */ |
| 685 | @Override | 684 | @Override |
| 686 | public BooleanTrue createBooleanTrue() | 685 | public Switch createSwitch() |
| 687 | { | 686 | { |
| 688 | BooleanTrueImpl booleanTrue = new BooleanTrueImpl(); | 687 | SwitchImpl switch_ = new SwitchImpl(); |
| 689 | return booleanTrue; | 688 | return switch_; |
| 690 | } | 689 | } |
| 691 | 690 | ||
| 692 | /** | 691 | /** |
| @@ -695,10 +694,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 695 | * @generated | 694 | * @generated |
| 696 | */ | 695 | */ |
| 697 | @Override | 696 | @Override |
| 698 | public BooleanFalse createBooleanFalse() | 697 | public Conjunction createConjunction() |
| 699 | { | 698 | { |
| 700 | BooleanFalseImpl booleanFalse = new BooleanFalseImpl(); | 699 | ConjunctionImpl conjunction = new ConjunctionImpl(); |
| 701 | return booleanFalse; | 700 | return conjunction; |
| 702 | } | 701 | } |
| 703 | 702 | ||
| 704 | /** | 703 | /** |
| @@ -707,10 +706,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 707 | * @generated | 706 | * @generated |
| 708 | */ | 707 | */ |
| 709 | @Override | 708 | @Override |
| 710 | public True createTrue() | 709 | public Comparison createComparison() |
| 711 | { | 710 | { |
| 712 | TrueImpl true_ = new TrueImpl(); | 711 | ComparisonImpl comparison = new ComparisonImpl(); |
| 713 | return true_; | 712 | return comparison; |
| 714 | } | 713 | } |
| 715 | 714 | ||
| 716 | /** | 715 | /** |
| @@ -719,10 +718,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 719 | * @generated | 718 | * @generated |
| 720 | */ | 719 | */ |
| 721 | @Override | 720 | @Override |
| 722 | public False createFalse() | 721 | public BinaryExpression createBinaryExpression() |
| 723 | { | 722 | { |
| 724 | FalseImpl false_ = new FalseImpl(); | 723 | BinaryExpressionImpl binaryExpression = new BinaryExpressionImpl(); |
| 725 | return false_; | 724 | return binaryExpression; |
| 726 | } | 725 | } |
| 727 | 726 | ||
| 728 | /** | 727 | /** |
| @@ -731,10 +730,10 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 731 | * @generated | 730 | * @generated |
| 732 | */ | 731 | */ |
| 733 | @Override | 732 | @Override |
| 734 | public Unknown createUnknown() | 733 | public UnaryExpression createUnaryExpression() |
| 735 | { | 734 | { |
| 736 | UnknownImpl unknown = new UnknownImpl(); | 735 | UnaryExpressionImpl unaryExpression = new UnaryExpressionImpl(); |
| 737 | return unknown; | 736 | return unaryExpression; |
| 738 | } | 737 | } |
| 739 | 738 | ||
| 740 | /** | 739 | /** |
| @@ -742,11 +741,11 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 742 | * <!-- end-user-doc --> | 741 | * <!-- end-user-doc --> |
| 743 | * @generated | 742 | * @generated |
| 744 | */ | 743 | */ |
| 745 | @Override | 744 | public MetricType createMetricTypeFromString(EDataType eDataType, String initialValue) |
| 746 | public org.eclipse.viatra.solver.language.solverLanguage.Error createError() | ||
| 747 | { | 745 | { |
| 748 | ErrorImpl error = new ErrorImpl(); | 746 | MetricType result = MetricType.get(initialValue); |
| 749 | return error; | 747 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); |
| 748 | return result; | ||
| 750 | } | 749 | } |
| 751 | 750 | ||
| 752 | /** | 751 | /** |
| @@ -754,11 +753,9 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 754 | * <!-- end-user-doc --> | 753 | * <!-- end-user-doc --> |
| 755 | * @generated | 754 | * @generated |
| 756 | */ | 755 | */ |
| 757 | @Override | 756 | public String convertMetricTypeToString(EDataType eDataType, Object instanceValue) |
| 758 | public Positive createPositive() | ||
| 759 | { | 757 | { |
| 760 | PositiveImpl positive = new PositiveImpl(); | 758 | return instanceValue == null ? null : instanceValue.toString(); |
| 761 | return positive; | ||
| 762 | } | 759 | } |
| 763 | 760 | ||
| 764 | /** | 761 | /** |
| @@ -766,11 +763,11 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 766 | * <!-- end-user-doc --> | 763 | * <!-- end-user-doc --> |
| 767 | * @generated | 764 | * @generated |
| 768 | */ | 765 | */ |
| 769 | @Override | 766 | public BinaryOperator createBinaryOperatorFromString(EDataType eDataType, String initialValue) |
| 770 | public Negative createNegative() | ||
| 771 | { | 767 | { |
| 772 | NegativeImpl negative = new NegativeImpl(); | 768 | BinaryOperator result = BinaryOperator.get(initialValue); |
| 773 | return negative; | 769 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); |
| 770 | return result; | ||
| 774 | } | 771 | } |
| 775 | 772 | ||
| 776 | /** | 773 | /** |
| @@ -778,11 +775,9 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 778 | * <!-- end-user-doc --> | 775 | * <!-- end-user-doc --> |
| 779 | * @generated | 776 | * @generated |
| 780 | */ | 777 | */ |
| 781 | @Override | 778 | public String convertBinaryOperatorToString(EDataType eDataType, Object instanceValue) |
| 782 | public ReflexiveClosure createReflexiveClosure() | ||
| 783 | { | 779 | { |
| 784 | ReflexiveClosureImpl reflexiveClosure = new ReflexiveClosureImpl(); | 780 | return instanceValue == null ? null : instanceValue.toString(); |
| 785 | return reflexiveClosure; | ||
| 786 | } | 781 | } |
| 787 | 782 | ||
| 788 | /** | 783 | /** |
| @@ -790,11 +785,87 @@ public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLan | |||
| 790 | * <!-- end-user-doc --> | 785 | * <!-- end-user-doc --> |
| 791 | * @generated | 786 | * @generated |
| 792 | */ | 787 | */ |
| 793 | @Override | 788 | public UnaryOp createUnaryOpFromString(EDataType eDataType, String initialValue) |
| 794 | public IrreflexiveClosure createIrreflexiveClosure() | 789 | { |
| 790 | UnaryOp result = UnaryOp.get(initialValue); | ||
| 791 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); | ||
| 792 | return result; | ||
| 793 | } | ||
| 794 | |||
| 795 | /** | ||
| 796 | * <!-- begin-user-doc --> | ||
| 797 | * <!-- end-user-doc --> | ||
| 798 | * @generated | ||
| 799 | */ | ||
| 800 | public String convertUnaryOpToString(EDataType eDataType, Object instanceValue) | ||
| 801 | { | ||
| 802 | return instanceValue == null ? null : instanceValue.toString(); | ||
| 803 | } | ||
| 804 | |||
| 805 | /** | ||
| 806 | * <!-- begin-user-doc --> | ||
| 807 | * <!-- end-user-doc --> | ||
| 808 | * @generated | ||
| 809 | */ | ||
| 810 | public AggregationOp createAggregationOpFromString(EDataType eDataType, String initialValue) | ||
| 811 | { | ||
| 812 | AggregationOp result = AggregationOp.get(initialValue); | ||
| 813 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); | ||
| 814 | return result; | ||
| 815 | } | ||
| 816 | |||
| 817 | /** | ||
| 818 | * <!-- begin-user-doc --> | ||
| 819 | * <!-- end-user-doc --> | ||
| 820 | * @generated | ||
| 821 | */ | ||
| 822 | public String convertAggregationOpToString(EDataType eDataType, Object instanceValue) | ||
| 823 | { | ||
| 824 | return instanceValue == null ? null : instanceValue.toString(); | ||
| 825 | } | ||
| 826 | |||
| 827 | /** | ||
| 828 | * <!-- begin-user-doc --> | ||
| 829 | * <!-- end-user-doc --> | ||
| 830 | * @generated | ||
| 831 | */ | ||
| 832 | public LogicValue createLogicValueFromString(EDataType eDataType, String initialValue) | ||
| 833 | { | ||
| 834 | LogicValue result = LogicValue.get(initialValue); | ||
| 835 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); | ||
| 836 | return result; | ||
| 837 | } | ||
| 838 | |||
| 839 | /** | ||
| 840 | * <!-- begin-user-doc --> | ||
| 841 | * <!-- end-user-doc --> | ||
| 842 | * @generated | ||
| 843 | */ | ||
| 844 | public String convertLogicValueToString(EDataType eDataType, Object instanceValue) | ||
| 845 | { | ||
| 846 | return instanceValue == null ? null : instanceValue.toString(); | ||
| 847 | } | ||
| 848 | |||
| 849 | /** | ||
| 850 | * <!-- begin-user-doc --> | ||
| 851 | * <!-- end-user-doc --> | ||
| 852 | * @generated | ||
| 853 | */ | ||
| 854 | public ObjectiveKind createObjectiveKindFromString(EDataType eDataType, String initialValue) | ||
| 855 | { | ||
| 856 | ObjectiveKind result = ObjectiveKind.get(initialValue); | ||
| 857 | if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); | ||
| 858 | return result; | ||
| 859 | } | ||
| 860 | |||
| 861 | /** | ||
| 862 | * <!-- begin-user-doc --> | ||
| 863 | * <!-- end-user-doc --> | ||
| 864 | * @generated | ||
| 865 | */ | ||
| 866 | public String convertObjectiveKindToString(EDataType eDataType, Object instanceValue) | ||
| 795 | { | 867 | { |
| 796 | IrreflexiveClosureImpl irreflexiveClosure = new IrreflexiveClosureImpl(); | 868 | return instanceValue == null ? null : instanceValue.toString(); |
| 797 | return irreflexiveClosure; | ||
| 798 | } | 869 | } |
| 799 | 870 | ||
| 800 | /** | 871 | /** |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java index f617be3f..39f811b9 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java | |||
| @@ -1,67 +1,71 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EAttribute; | 6 | import org.eclipse.emf.ecore.EAttribute; |
| 7 | import org.eclipse.emf.ecore.EClass; | 7 | import org.eclipse.emf.ecore.EClass; |
| 8 | import org.eclipse.emf.ecore.EEnum; | ||
| 8 | import org.eclipse.emf.ecore.EPackage; | 9 | import org.eclipse.emf.ecore.EPackage; |
| 9 | import org.eclipse.emf.ecore.EReference; | 10 | import org.eclipse.emf.ecore.EReference; |
| 10 | 11 | ||
| 11 | import org.eclipse.emf.ecore.impl.EPackageImpl; | 12 | import org.eclipse.emf.ecore.impl.EPackageImpl; |
| 12 | 13 | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 14 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; |
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | 15 | import org.eclipse.viatra.solver.language.solverLanguage.AggregationOp; |
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | 16 | import org.eclipse.viatra.solver.language.solverLanguage.Argument; |
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | 17 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; |
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | 18 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; |
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | 19 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; |
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | 20 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryOperator; |
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | 21 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; |
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; | 22 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition; |
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | 23 | import org.eclipse.viatra.solver.language.solverLanguage.Call; |
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | 24 | import org.eclipse.viatra.solver.language.solverLanguage.Case; |
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | 25 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition; |
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | 26 | import org.eclipse.viatra.solver.language.solverLanguage.Comparison; |
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.DataObject; | 27 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; |
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; | 28 | import org.eclipse.viatra.solver.language.solverLanguage.Count; |
| 28 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | 29 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition; |
| 29 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | 30 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; |
| 30 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | 31 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral; |
| 31 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | 32 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; |
| 32 | import org.eclipse.viatra.solver.language.solverLanguage.False; | 33 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition; |
| 33 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | 34 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; |
| 34 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | 35 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; |
| 35 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | 36 | import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition; |
| 36 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | 37 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition; |
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | 38 | import org.eclipse.viatra.solver.language.solverLanguage.IfElse; |
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | 39 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; |
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; | ||
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | 41 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; |
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | 42 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; |
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | 43 | import org.eclipse.viatra.solver.language.solverLanguage.LogicValue; |
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | 44 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition; |
| 43 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | 45 | import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity; |
| 44 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | 46 | import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition; |
| 45 | import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; | 47 | import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition; |
| 46 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | 48 | import org.eclipse.viatra.solver.language.solverLanguage.MetricType; |
| 47 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | 49 | import org.eclipse.viatra.solver.language.solverLanguage.Multiplicity; |
| 48 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | 50 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; |
| 49 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | 51 | import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral; |
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition; | ||
| 53 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveKind; | ||
| 54 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | ||
| 50 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | 55 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; |
| 51 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | 56 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; |
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | 57 | import org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition; |
| 53 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 54 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory; | 58 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory; |
| 55 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 59 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 60 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; | ||
| 56 | import org.eclipse.viatra.solver.language.solverLanguage.Statement; | 61 | import org.eclipse.viatra.solver.language.solverLanguage.Statement; |
| 57 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | 62 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; |
| 58 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | 63 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; |
| 59 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | 64 | import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument; |
| 60 | import org.eclipse.viatra.solver.language.solverLanguage.True; | 65 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; |
| 61 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | 66 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; |
| 62 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | 67 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryOp; |
| 63 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | 68 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition; |
| 64 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 65 | 69 | ||
| 66 | /** | 70 | /** |
| 67 | * <!-- begin-user-doc --> | 71 | * <!-- begin-user-doc --> |
| @@ -90,350 +94,357 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 90 | * <!-- end-user-doc --> | 94 | * <!-- end-user-doc --> |
| 91 | * @generated | 95 | * @generated |
| 92 | */ | 96 | */ |
| 93 | private EClass booleanValueEClass = null; | 97 | private EClass predicateDefinitionEClass = null; |
| 94 | 98 | ||
| 95 | /** | 99 | /** |
| 96 | * <!-- begin-user-doc --> | 100 | * <!-- begin-user-doc --> |
| 97 | * <!-- end-user-doc --> | 101 | * <!-- end-user-doc --> |
| 98 | * @generated | 102 | * @generated |
| 99 | */ | 103 | */ |
| 100 | private EClass truthValueEClass = null; | 104 | private EClass unnamedErrorPrediateDefinitionEClass = null; |
| 101 | 105 | ||
| 102 | /** | 106 | /** |
| 103 | * <!-- begin-user-doc --> | 107 | * <!-- begin-user-doc --> |
| 104 | * <!-- end-user-doc --> | 108 | * <!-- end-user-doc --> |
| 105 | * @generated | 109 | * @generated |
| 106 | */ | 110 | */ |
| 107 | private EClass interpretationEClass = null; | 111 | private EClass defaultDefinitionEClass = null; |
| 108 | 112 | ||
| 109 | /** | 113 | /** |
| 110 | * <!-- begin-user-doc --> | 114 | * <!-- begin-user-doc --> |
| 111 | * <!-- end-user-doc --> | 115 | * <!-- end-user-doc --> |
| 112 | * @generated | 116 | * @generated |
| 113 | */ | 117 | */ |
| 114 | private EClass basicInterpretationEClass = null; | 118 | private EClass externPredicateDefinitionEClass = null; |
| 115 | 119 | ||
| 116 | /** | 120 | /** |
| 117 | * <!-- begin-user-doc --> | 121 | * <!-- begin-user-doc --> |
| 118 | * <!-- end-user-doc --> | 122 | * <!-- end-user-doc --> |
| 119 | * @generated | 123 | * @generated |
| 120 | */ | 124 | */ |
| 121 | private EClass symbolEClass = null; | 125 | private EClass metricDefinitionEClass = null; |
| 122 | 126 | ||
| 123 | /** | 127 | /** |
| 124 | * <!-- begin-user-doc --> | 128 | * <!-- begin-user-doc --> |
| 125 | * <!-- end-user-doc --> | 129 | * <!-- end-user-doc --> |
| 126 | * @generated | 130 | * @generated |
| 127 | */ | 131 | */ |
| 128 | private EClass modelSymbolEClass = null; | 132 | private EClass externMetricDefinitionEClass = null; |
| 129 | 133 | ||
| 130 | /** | 134 | /** |
| 131 | * <!-- begin-user-doc --> | 135 | * <!-- begin-user-doc --> |
| 132 | * <!-- end-user-doc --> | 136 | * <!-- end-user-doc --> |
| 133 | * @generated | 137 | * @generated |
| 134 | */ | 138 | */ |
| 135 | private EClass partialitySymbolEClass = null; | 139 | private EClass expressionEClass = null; |
| 136 | 140 | ||
| 137 | /** | 141 | /** |
| 138 | * <!-- begin-user-doc --> | 142 | * <!-- begin-user-doc --> |
| 139 | * <!-- end-user-doc --> | 143 | * <!-- end-user-doc --> |
| 140 | * @generated | 144 | * @generated |
| 141 | */ | 145 | */ |
| 142 | private EClass existSymbolEClass = null; | 146 | private EClass ifElseEClass = null; |
| 143 | 147 | ||
| 144 | /** | 148 | /** |
| 145 | * <!-- begin-user-doc --> | 149 | * <!-- begin-user-doc --> |
| 146 | * <!-- end-user-doc --> | 150 | * <!-- end-user-doc --> |
| 147 | * @generated | 151 | * @generated |
| 148 | */ | 152 | */ |
| 149 | private EClass equalsSymbolEClass = null; | 153 | private EClass caseEClass = null; |
| 150 | 154 | ||
| 151 | /** | 155 | /** |
| 152 | * <!-- begin-user-doc --> | 156 | * <!-- begin-user-doc --> |
| 153 | * <!-- end-user-doc --> | 157 | * <!-- end-user-doc --> |
| 154 | * @generated | 158 | * @generated |
| 155 | */ | 159 | */ |
| 156 | private EClass dataSymbolEClass = null; | 160 | private EClass countEClass = null; |
| 157 | 161 | ||
| 158 | /** | 162 | /** |
| 159 | * <!-- begin-user-doc --> | 163 | * <!-- begin-user-doc --> |
| 160 | * <!-- end-user-doc --> | 164 | * <!-- end-user-doc --> |
| 161 | * @generated | 165 | * @generated |
| 162 | */ | 166 | */ |
| 163 | private EClass booleanSymbolEClass = null; | 167 | private EClass aggregationEClass = null; |
| 164 | 168 | ||
| 165 | /** | 169 | /** |
| 166 | * <!-- begin-user-doc --> | 170 | * <!-- begin-user-doc --> |
| 167 | * <!-- end-user-doc --> | 171 | * <!-- end-user-doc --> |
| 168 | * @generated | 172 | * @generated |
| 169 | */ | 173 | */ |
| 170 | private EClass integerSymbolEClass = null; | 174 | private EClass callEClass = null; |
| 171 | 175 | ||
| 172 | /** | 176 | /** |
| 173 | * <!-- begin-user-doc --> | 177 | * <!-- begin-user-doc --> |
| 174 | * <!-- end-user-doc --> | 178 | * <!-- end-user-doc --> |
| 175 | * @generated | 179 | * @generated |
| 176 | */ | 180 | */ |
| 177 | private EClass realSymbolEClass = null; | 181 | private EClass argumentListEClass = null; |
| 178 | 182 | ||
| 179 | /** | 183 | /** |
| 180 | * <!-- begin-user-doc --> | 184 | * <!-- begin-user-doc --> |
| 181 | * <!-- end-user-doc --> | 185 | * <!-- end-user-doc --> |
| 182 | * @generated | 186 | * @generated |
| 183 | */ | 187 | */ |
| 184 | private EClass stringSymbolEClass = null; | 188 | private EClass argumentEClass = null; |
| 185 | 189 | ||
| 186 | /** | 190 | /** |
| 187 | * <!-- begin-user-doc --> | 191 | * <!-- begin-user-doc --> |
| 188 | * <!-- end-user-doc --> | 192 | * <!-- end-user-doc --> |
| 189 | * @generated | 193 | * @generated |
| 190 | */ | 194 | */ |
| 191 | private EClass complexObjectEClass = null; | 195 | private EClass expressionArgumentEClass = null; |
| 192 | 196 | ||
| 193 | /** | 197 | /** |
| 194 | * <!-- begin-user-doc --> | 198 | * <!-- begin-user-doc --> |
| 195 | * <!-- end-user-doc --> | 199 | * <!-- end-user-doc --> |
| 196 | * @generated | 200 | * @generated |
| 197 | */ | 201 | */ |
| 198 | private EClass objectEClass = null; | 202 | private EClass starArgumentEClass = null; |
| 199 | 203 | ||
| 200 | /** | 204 | /** |
| 201 | * <!-- begin-user-doc --> | 205 | * <!-- begin-user-doc --> |
| 202 | * <!-- end-user-doc --> | 206 | * <!-- end-user-doc --> |
| 203 | * @generated | 207 | * @generated |
| 204 | */ | 208 | */ |
| 205 | private EClass namedObjectEClass = null; | 209 | private EClass typedArgumentEClass = null; |
| 206 | 210 | ||
| 207 | /** | 211 | /** |
| 208 | * <!-- begin-user-doc --> | 212 | * <!-- begin-user-doc --> |
| 209 | * <!-- end-user-doc --> | 213 | * <!-- end-user-doc --> |
| 210 | * @generated | 214 | * @generated |
| 211 | */ | 215 | */ |
| 212 | private EClass unnamedObjectEClass = null; | 216 | private EClass typedStarArgumentEClass = null; |
| 213 | 217 | ||
| 214 | /** | 218 | /** |
| 215 | * <!-- begin-user-doc --> | 219 | * <!-- begin-user-doc --> |
| 216 | * <!-- end-user-doc --> | 220 | * <!-- end-user-doc --> |
| 217 | * @generated | 221 | * @generated |
| 218 | */ | 222 | */ |
| 219 | private EClass dataObjectEClass = null; | 223 | private EClass referenceEClass = null; |
| 220 | 224 | ||
| 221 | /** | 225 | /** |
| 222 | * <!-- begin-user-doc --> | 226 | * <!-- begin-user-doc --> |
| 223 | * <!-- end-user-doc --> | 227 | * <!-- end-user-doc --> |
| 224 | * @generated | 228 | * @generated |
| 225 | */ | 229 | */ |
| 226 | private EClass booleanObjectEClass = null; | 230 | private EClass intervalEClass = null; |
| 227 | 231 | ||
| 228 | /** | 232 | /** |
| 229 | * <!-- begin-user-doc --> | 233 | * <!-- begin-user-doc --> |
| 230 | * <!-- end-user-doc --> | 234 | * <!-- end-user-doc --> |
| 231 | * @generated | 235 | * @generated |
| 232 | */ | 236 | */ |
| 233 | private EClass intObjectEClass = null; | 237 | private EClass literalEClass = null; |
| 234 | 238 | ||
| 235 | /** | 239 | /** |
| 236 | * <!-- begin-user-doc --> | 240 | * <!-- begin-user-doc --> |
| 237 | * <!-- end-user-doc --> | 241 | * <!-- end-user-doc --> |
| 238 | * @generated | 242 | * @generated |
| 239 | */ | 243 | */ |
| 240 | private EClass realObjectEClass = null; | 244 | private EClass logicLiteralEClass = null; |
| 241 | 245 | ||
| 242 | /** | 246 | /** |
| 243 | * <!-- begin-user-doc --> | 247 | * <!-- begin-user-doc --> |
| 244 | * <!-- end-user-doc --> | 248 | * <!-- end-user-doc --> |
| 245 | * @generated | 249 | * @generated |
| 246 | */ | 250 | */ |
| 247 | private EClass stringObjectEClass = null; | 251 | private EClass numericLiteralEClass = null; |
| 248 | 252 | ||
| 249 | /** | 253 | /** |
| 250 | * <!-- begin-user-doc --> | 254 | * <!-- begin-user-doc --> |
| 251 | * <!-- end-user-doc --> | 255 | * <!-- end-user-doc --> |
| 252 | * @generated | 256 | * @generated |
| 253 | */ | 257 | */ |
| 254 | private EClass predicateEClass = null; | 258 | private EClass infinityLiteralEClass = null; |
| 255 | 259 | ||
| 256 | /** | 260 | /** |
| 257 | * <!-- begin-user-doc --> | 261 | * <!-- begin-user-doc --> |
| 258 | * <!-- end-user-doc --> | 262 | * <!-- end-user-doc --> |
| 259 | * @generated | 263 | * @generated |
| 260 | */ | 264 | */ |
| 261 | private EClass parameterEClass = null; | 265 | private EClass emptyIntervalLiteralEClass = null; |
| 262 | 266 | ||
| 263 | /** | 267 | /** |
| 264 | * <!-- begin-user-doc --> | 268 | * <!-- begin-user-doc --> |
| 265 | * <!-- end-user-doc --> | 269 | * <!-- end-user-doc --> |
| 266 | * @generated | 270 | * @generated |
| 267 | */ | 271 | */ |
| 268 | private EClass patternBodyEClass = null; | 272 | private EClass stringLiteralEClass = null; |
| 269 | 273 | ||
| 270 | /** | 274 | /** |
| 271 | * <!-- begin-user-doc --> | 275 | * <!-- begin-user-doc --> |
| 272 | * <!-- end-user-doc --> | 276 | * <!-- end-user-doc --> |
| 273 | * @generated | 277 | * @generated |
| 274 | */ | 278 | */ |
| 275 | private EClass polarityEClass = null; | 279 | private EClass classDefinitionEClass = null; |
| 276 | 280 | ||
| 277 | /** | 281 | /** |
| 278 | * <!-- begin-user-doc --> | 282 | * <!-- begin-user-doc --> |
| 279 | * <!-- end-user-doc --> | 283 | * <!-- end-user-doc --> |
| 280 | * @generated | 284 | * @generated |
| 281 | */ | 285 | */ |
| 282 | private EClass constraintEClass = null; | 286 | private EClass memberDefinitionEClass = null; |
| 283 | 287 | ||
| 284 | /** | 288 | /** |
| 285 | * <!-- begin-user-doc --> | 289 | * <!-- begin-user-doc --> |
| 286 | * <!-- end-user-doc --> | 290 | * <!-- end-user-doc --> |
| 287 | * @generated | 291 | * @generated |
| 288 | */ | 292 | */ |
| 289 | private EClass closureTypeEClass = null; | 293 | private EClass multiplicityEClass = null; |
| 290 | 294 | ||
| 291 | /** | 295 | /** |
| 292 | * <!-- begin-user-doc --> | 296 | * <!-- begin-user-doc --> |
| 293 | * <!-- end-user-doc --> | 297 | * <!-- end-user-doc --> |
| 294 | * @generated | 298 | * @generated |
| 295 | */ | 299 | */ |
| 296 | private EClass literalEClass = null; | 300 | private EClass manyMultiplicityEClass = null; |
| 301 | |||
| 302 | /** | ||
| 303 | * <!-- begin-user-doc --> | ||
| 304 | * <!-- end-user-doc --> | ||
| 305 | * @generated | ||
| 306 | */ | ||
| 307 | private EClass exactMultiplicityEClass = null; | ||
| 297 | 308 | ||
| 298 | /** | 309 | /** |
| 299 | * <!-- begin-user-doc --> | 310 | * <!-- begin-user-doc --> |
| 300 | * <!-- end-user-doc --> | 311 | * <!-- end-user-doc --> |
| 301 | * @generated | 312 | * @generated |
| 302 | */ | 313 | */ |
| 303 | private EClass variableEClass = null; | 314 | private EClass boundedMultiplicityEClass = null; |
| 304 | 315 | ||
| 305 | /** | 316 | /** |
| 306 | * <!-- begin-user-doc --> | 317 | * <!-- begin-user-doc --> |
| 307 | * <!-- end-user-doc --> | 318 | * <!-- end-user-doc --> |
| 308 | * @generated | 319 | * @generated |
| 309 | */ | 320 | */ |
| 310 | private EClass allInstancesEClass = null; | 321 | private EClass scopeDefinitionEClass = null; |
| 311 | 322 | ||
| 312 | /** | 323 | /** |
| 313 | * <!-- begin-user-doc --> | 324 | * <!-- begin-user-doc --> |
| 314 | * <!-- end-user-doc --> | 325 | * <!-- end-user-doc --> |
| 315 | * @generated | 326 | * @generated |
| 316 | */ | 327 | */ |
| 317 | private EClass allObjectsEClass = null; | 328 | private EClass exactScopeDefinitionEClass = null; |
| 318 | 329 | ||
| 319 | /** | 330 | /** |
| 320 | * <!-- begin-user-doc --> | 331 | * <!-- begin-user-doc --> |
| 321 | * <!-- end-user-doc --> | 332 | * <!-- end-user-doc --> |
| 322 | * @generated | 333 | * @generated |
| 323 | */ | 334 | */ |
| 324 | private EClass defaultInterpretationEClass = null; | 335 | private EClass boundedScopeDefinitionEClass = null; |
| 325 | 336 | ||
| 326 | /** | 337 | /** |
| 327 | * <!-- begin-user-doc --> | 338 | * <!-- begin-user-doc --> |
| 328 | * <!-- end-user-doc --> | 339 | * <!-- end-user-doc --> |
| 329 | * @generated | 340 | * @generated |
| 330 | */ | 341 | */ |
| 331 | private EClass cdInterpretationEClass = null; | 342 | private EClass lowerBoundedScopeDefinitionEClass = null; |
| 332 | 343 | ||
| 333 | /** | 344 | /** |
| 334 | * <!-- begin-user-doc --> | 345 | * <!-- begin-user-doc --> |
| 335 | * <!-- end-user-doc --> | 346 | * <!-- end-user-doc --> |
| 336 | * @generated | 347 | * @generated |
| 337 | */ | 348 | */ |
| 338 | private EClass classInterpretationEClass = null; | 349 | private EClass objectiveDefinitionEClass = null; |
| 339 | 350 | ||
| 340 | /** | 351 | /** |
| 341 | * <!-- begin-user-doc --> | 352 | * <!-- begin-user-doc --> |
| 342 | * <!-- end-user-doc --> | 353 | * <!-- end-user-doc --> |
| 343 | * @generated | 354 | * @generated |
| 344 | */ | 355 | */ |
| 345 | private EClass enumInterpretationEClass = null; | 356 | private EClass namedElementEClass = null; |
| 346 | 357 | ||
| 347 | /** | 358 | /** |
| 348 | * <!-- begin-user-doc --> | 359 | * <!-- begin-user-doc --> |
| 349 | * <!-- end-user-doc --> | 360 | * <!-- end-user-doc --> |
| 350 | * @generated | 361 | * @generated |
| 351 | */ | 362 | */ |
| 352 | private EClass fieldRelationInterpretationEClass = null; | 363 | private EClass assertionEClass = null; |
| 353 | 364 | ||
| 354 | /** | 365 | /** |
| 355 | * <!-- begin-user-doc --> | 366 | * <!-- begin-user-doc --> |
| 356 | * <!-- end-user-doc --> | 367 | * <!-- end-user-doc --> |
| 357 | * @generated | 368 | * @generated |
| 358 | */ | 369 | */ |
| 359 | private EClass globalRelationInterpretationEClass = null; | 370 | private EClass disjunctionEClass = null; |
| 360 | 371 | ||
| 361 | /** | 372 | /** |
| 362 | * <!-- begin-user-doc --> | 373 | * <!-- begin-user-doc --> |
| 363 | * <!-- end-user-doc --> | 374 | * <!-- end-user-doc --> |
| 364 | * @generated | 375 | * @generated |
| 365 | */ | 376 | */ |
| 366 | private EClass multiplicityDefinitionEClass = null; | 377 | private EClass switchEClass = null; |
| 367 | 378 | ||
| 368 | /** | 379 | /** |
| 369 | * <!-- begin-user-doc --> | 380 | * <!-- begin-user-doc --> |
| 370 | * <!-- end-user-doc --> | 381 | * <!-- end-user-doc --> |
| 371 | * @generated | 382 | * @generated |
| 372 | */ | 383 | */ |
| 373 | private EClass booleanTrueEClass = null; | 384 | private EClass conjunctionEClass = null; |
| 374 | 385 | ||
| 375 | /** | 386 | /** |
| 376 | * <!-- begin-user-doc --> | 387 | * <!-- begin-user-doc --> |
| 377 | * <!-- end-user-doc --> | 388 | * <!-- end-user-doc --> |
| 378 | * @generated | 389 | * @generated |
| 379 | */ | 390 | */ |
| 380 | private EClass booleanFalseEClass = null; | 391 | private EClass comparisonEClass = null; |
| 381 | 392 | ||
| 382 | /** | 393 | /** |
| 383 | * <!-- begin-user-doc --> | 394 | * <!-- begin-user-doc --> |
| 384 | * <!-- end-user-doc --> | 395 | * <!-- end-user-doc --> |
| 385 | * @generated | 396 | * @generated |
| 386 | */ | 397 | */ |
| 387 | private EClass trueEClass = null; | 398 | private EClass binaryExpressionEClass = null; |
| 388 | 399 | ||
| 389 | /** | 400 | /** |
| 390 | * <!-- begin-user-doc --> | 401 | * <!-- begin-user-doc --> |
| 391 | * <!-- end-user-doc --> | 402 | * <!-- end-user-doc --> |
| 392 | * @generated | 403 | * @generated |
| 393 | */ | 404 | */ |
| 394 | private EClass falseEClass = null; | 405 | private EClass unaryExpressionEClass = null; |
| 395 | 406 | ||
| 396 | /** | 407 | /** |
| 397 | * <!-- begin-user-doc --> | 408 | * <!-- begin-user-doc --> |
| 398 | * <!-- end-user-doc --> | 409 | * <!-- end-user-doc --> |
| 399 | * @generated | 410 | * @generated |
| 400 | */ | 411 | */ |
| 401 | private EClass unknownEClass = null; | 412 | private EEnum metricTypeEEnum = null; |
| 402 | 413 | ||
| 403 | /** | 414 | /** |
| 404 | * <!-- begin-user-doc --> | 415 | * <!-- begin-user-doc --> |
| 405 | * <!-- end-user-doc --> | 416 | * <!-- end-user-doc --> |
| 406 | * @generated | 417 | * @generated |
| 407 | */ | 418 | */ |
| 408 | private EClass errorEClass = null; | 419 | private EEnum binaryOperatorEEnum = null; |
| 409 | 420 | ||
| 410 | /** | 421 | /** |
| 411 | * <!-- begin-user-doc --> | 422 | * <!-- begin-user-doc --> |
| 412 | * <!-- end-user-doc --> | 423 | * <!-- end-user-doc --> |
| 413 | * @generated | 424 | * @generated |
| 414 | */ | 425 | */ |
| 415 | private EClass positiveEClass = null; | 426 | private EEnum unaryOpEEnum = null; |
| 416 | 427 | ||
| 417 | /** | 428 | /** |
| 418 | * <!-- begin-user-doc --> | 429 | * <!-- begin-user-doc --> |
| 419 | * <!-- end-user-doc --> | 430 | * <!-- end-user-doc --> |
| 420 | * @generated | 431 | * @generated |
| 421 | */ | 432 | */ |
| 422 | private EClass negativeEClass = null; | 433 | private EEnum aggregationOpEEnum = null; |
| 423 | 434 | ||
| 424 | /** | 435 | /** |
| 425 | * <!-- begin-user-doc --> | 436 | * <!-- begin-user-doc --> |
| 426 | * <!-- end-user-doc --> | 437 | * <!-- end-user-doc --> |
| 427 | * @generated | 438 | * @generated |
| 428 | */ | 439 | */ |
| 429 | private EClass reflexiveClosureEClass = null; | 440 | private EEnum logicValueEEnum = null; |
| 430 | 441 | ||
| 431 | /** | 442 | /** |
| 432 | * <!-- begin-user-doc --> | 443 | * <!-- begin-user-doc --> |
| 433 | * <!-- end-user-doc --> | 444 | * <!-- end-user-doc --> |
| 434 | * @generated | 445 | * @generated |
| 435 | */ | 446 | */ |
| 436 | private EClass irreflexiveClosureEClass = null; | 447 | private EEnum objectiveKindEEnum = null; |
| 437 | 448 | ||
| 438 | /** | 449 | /** |
| 439 | * Creates an instance of the model <b>Package</b>, registered with | 450 | * Creates an instance of the model <b>Package</b>, registered with |
| @@ -537,9 +548,31 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 537 | * @generated | 548 | * @generated |
| 538 | */ | 549 | */ |
| 539 | @Override | 550 | @Override |
| 540 | public EClass getBooleanValue() | 551 | public EClass getPredicateDefinition() |
| 552 | { | ||
| 553 | return predicateDefinitionEClass; | ||
| 554 | } | ||
| 555 | |||
| 556 | /** | ||
| 557 | * <!-- begin-user-doc --> | ||
| 558 | * <!-- end-user-doc --> | ||
| 559 | * @generated | ||
| 560 | */ | ||
| 561 | @Override | ||
| 562 | public EReference getPredicateDefinition_Head() | ||
| 563 | { | ||
| 564 | return (EReference)predicateDefinitionEClass.getEStructuralFeatures().get(0); | ||
| 565 | } | ||
| 566 | |||
| 567 | /** | ||
| 568 | * <!-- begin-user-doc --> | ||
| 569 | * <!-- end-user-doc --> | ||
| 570 | * @generated | ||
| 571 | */ | ||
| 572 | @Override | ||
| 573 | public EReference getPredicateDefinition_Body() | ||
| 541 | { | 574 | { |
| 542 | return booleanValueEClass; | 575 | return (EReference)predicateDefinitionEClass.getEStructuralFeatures().get(1); |
| 543 | } | 576 | } |
| 544 | 577 | ||
| 545 | /** | 578 | /** |
| @@ -548,9 +581,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 548 | * @generated | 581 | * @generated |
| 549 | */ | 582 | */ |
| 550 | @Override | 583 | @Override |
| 551 | public EClass getTruthValue() | 584 | public EAttribute getPredicateDefinition_Functional() |
| 552 | { | 585 | { |
| 553 | return truthValueEClass; | 586 | return (EAttribute)predicateDefinitionEClass.getEStructuralFeatures().get(2); |
| 554 | } | 587 | } |
| 555 | 588 | ||
| 556 | /** | 589 | /** |
| @@ -559,9 +592,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 559 | * @generated | 592 | * @generated |
| 560 | */ | 593 | */ |
| 561 | @Override | 594 | @Override |
| 562 | public EClass getInterpretation() | 595 | public EAttribute getPredicateDefinition_Error() |
| 563 | { | 596 | { |
| 564 | return interpretationEClass; | 597 | return (EAttribute)predicateDefinitionEClass.getEStructuralFeatures().get(3); |
| 565 | } | 598 | } |
| 566 | 599 | ||
| 567 | /** | 600 | /** |
| @@ -570,9 +603,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 570 | * @generated | 603 | * @generated |
| 571 | */ | 604 | */ |
| 572 | @Override | 605 | @Override |
| 573 | public EClass getBasicInterpretation() | 606 | public EClass getUnnamedErrorPrediateDefinition() |
| 574 | { | 607 | { |
| 575 | return basicInterpretationEClass; | 608 | return unnamedErrorPrediateDefinitionEClass; |
| 576 | } | 609 | } |
| 577 | 610 | ||
| 578 | /** | 611 | /** |
| @@ -581,9 +614,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 581 | * @generated | 614 | * @generated |
| 582 | */ | 615 | */ |
| 583 | @Override | 616 | @Override |
| 584 | public EReference getBasicInterpretation_Symbol() | 617 | public EReference getUnnamedErrorPrediateDefinition_ArgumentList() |
| 585 | { | 618 | { |
| 586 | return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(0); | 619 | return (EReference)unnamedErrorPrediateDefinitionEClass.getEStructuralFeatures().get(0); |
| 587 | } | 620 | } |
| 588 | 621 | ||
| 589 | /** | 622 | /** |
| @@ -592,9 +625,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 592 | * @generated | 625 | * @generated |
| 593 | */ | 626 | */ |
| 594 | @Override | 627 | @Override |
| 595 | public EReference getBasicInterpretation_Objects() | 628 | public EReference getUnnamedErrorPrediateDefinition_Body() |
| 596 | { | 629 | { |
| 597 | return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(1); | 630 | return (EReference)unnamedErrorPrediateDefinitionEClass.getEStructuralFeatures().get(1); |
| 598 | } | 631 | } |
| 599 | 632 | ||
| 600 | /** | 633 | /** |
| @@ -603,9 +636,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 603 | * @generated | 636 | * @generated |
| 604 | */ | 637 | */ |
| 605 | @Override | 638 | @Override |
| 606 | public EReference getBasicInterpretation_Value() | 639 | public EClass getDefaultDefinition() |
| 607 | { | 640 | { |
| 608 | return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(2); | 641 | return defaultDefinitionEClass; |
| 609 | } | 642 | } |
| 610 | 643 | ||
| 611 | /** | 644 | /** |
| @@ -614,9 +647,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 614 | * @generated | 647 | * @generated |
| 615 | */ | 648 | */ |
| 616 | @Override | 649 | @Override |
| 617 | public EClass getSymbol() | 650 | public EReference getDefaultDefinition_Head() |
| 618 | { | 651 | { |
| 619 | return symbolEClass; | 652 | return (EReference)defaultDefinitionEClass.getEStructuralFeatures().get(0); |
| 620 | } | 653 | } |
| 621 | 654 | ||
| 622 | /** | 655 | /** |
| @@ -625,9 +658,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 625 | * @generated | 658 | * @generated |
| 626 | */ | 659 | */ |
| 627 | @Override | 660 | @Override |
| 628 | public EClass getModelSymbol() | 661 | public EReference getDefaultDefinition_Range() |
| 629 | { | 662 | { |
| 630 | return modelSymbolEClass; | 663 | return (EReference)defaultDefinitionEClass.getEStructuralFeatures().get(1); |
| 631 | } | 664 | } |
| 632 | 665 | ||
| 633 | /** | 666 | /** |
| @@ -636,9 +669,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 636 | * @generated | 669 | * @generated |
| 637 | */ | 670 | */ |
| 638 | @Override | 671 | @Override |
| 639 | public EAttribute getModelSymbol_Name() | 672 | public EClass getExternPredicateDefinition() |
| 640 | { | 673 | { |
| 641 | return (EAttribute)modelSymbolEClass.getEStructuralFeatures().get(0); | 674 | return externPredicateDefinitionEClass; |
| 642 | } | 675 | } |
| 643 | 676 | ||
| 644 | /** | 677 | /** |
| @@ -647,9 +680,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 647 | * @generated | 680 | * @generated |
| 648 | */ | 681 | */ |
| 649 | @Override | 682 | @Override |
| 650 | public EClass getPartialitySymbol() | 683 | public EReference getExternPredicateDefinition_Head() |
| 651 | { | 684 | { |
| 652 | return partialitySymbolEClass; | 685 | return (EReference)externPredicateDefinitionEClass.getEStructuralFeatures().get(0); |
| 653 | } | 686 | } |
| 654 | 687 | ||
| 655 | /** | 688 | /** |
| @@ -658,9 +691,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 658 | * @generated | 691 | * @generated |
| 659 | */ | 692 | */ |
| 660 | @Override | 693 | @Override |
| 661 | public EClass getExistSymbol() | 694 | public EClass getMetricDefinition() |
| 662 | { | 695 | { |
| 663 | return existSymbolEClass; | 696 | return metricDefinitionEClass; |
| 664 | } | 697 | } |
| 665 | 698 | ||
| 666 | /** | 699 | /** |
| @@ -669,9 +702,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 669 | * @generated | 702 | * @generated |
| 670 | */ | 703 | */ |
| 671 | @Override | 704 | @Override |
| 672 | public EClass getEqualsSymbol() | 705 | public EReference getMetricDefinition_Head() |
| 673 | { | 706 | { |
| 674 | return equalsSymbolEClass; | 707 | return (EReference)metricDefinitionEClass.getEStructuralFeatures().get(0); |
| 675 | } | 708 | } |
| 676 | 709 | ||
| 677 | /** | 710 | /** |
| @@ -680,9 +713,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 680 | * @generated | 713 | * @generated |
| 681 | */ | 714 | */ |
| 682 | @Override | 715 | @Override |
| 683 | public EClass getDataSymbol() | 716 | public EReference getMetricDefinition_Body() |
| 684 | { | 717 | { |
| 685 | return dataSymbolEClass; | 718 | return (EReference)metricDefinitionEClass.getEStructuralFeatures().get(1); |
| 686 | } | 719 | } |
| 687 | 720 | ||
| 688 | /** | 721 | /** |
| @@ -691,9 +724,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 691 | * @generated | 724 | * @generated |
| 692 | */ | 725 | */ |
| 693 | @Override | 726 | @Override |
| 694 | public EClass getBooleanSymbol() | 727 | public EAttribute getMetricDefinition_Type() |
| 695 | { | 728 | { |
| 696 | return booleanSymbolEClass; | 729 | return (EAttribute)metricDefinitionEClass.getEStructuralFeatures().get(2); |
| 697 | } | 730 | } |
| 698 | 731 | ||
| 699 | /** | 732 | /** |
| @@ -702,9 +735,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 702 | * @generated | 735 | * @generated |
| 703 | */ | 736 | */ |
| 704 | @Override | 737 | @Override |
| 705 | public EClass getIntegerSymbol() | 738 | public EClass getExternMetricDefinition() |
| 706 | { | 739 | { |
| 707 | return integerSymbolEClass; | 740 | return externMetricDefinitionEClass; |
| 708 | } | 741 | } |
| 709 | 742 | ||
| 710 | /** | 743 | /** |
| @@ -713,9 +746,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 713 | * @generated | 746 | * @generated |
| 714 | */ | 747 | */ |
| 715 | @Override | 748 | @Override |
| 716 | public EClass getRealSymbol() | 749 | public EAttribute getExternMetricDefinition_Type() |
| 717 | { | 750 | { |
| 718 | return realSymbolEClass; | 751 | return (EAttribute)externMetricDefinitionEClass.getEStructuralFeatures().get(0); |
| 719 | } | 752 | } |
| 720 | 753 | ||
| 721 | /** | 754 | /** |
| @@ -724,9 +757,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 724 | * @generated | 757 | * @generated |
| 725 | */ | 758 | */ |
| 726 | @Override | 759 | @Override |
| 727 | public EClass getStringSymbol() | 760 | public EReference getExternMetricDefinition_Head() |
| 728 | { | 761 | { |
| 729 | return stringSymbolEClass; | 762 | return (EReference)externMetricDefinitionEClass.getEStructuralFeatures().get(1); |
| 730 | } | 763 | } |
| 731 | 764 | ||
| 732 | /** | 765 | /** |
| @@ -735,9 +768,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 735 | * @generated | 768 | * @generated |
| 736 | */ | 769 | */ |
| 737 | @Override | 770 | @Override |
| 738 | public EClass getComplexObject() | 771 | public EClass getExpression() |
| 739 | { | 772 | { |
| 740 | return complexObjectEClass; | 773 | return expressionEClass; |
| 741 | } | 774 | } |
| 742 | 775 | ||
| 743 | /** | 776 | /** |
| @@ -746,9 +779,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 746 | * @generated | 779 | * @generated |
| 747 | */ | 780 | */ |
| 748 | @Override | 781 | @Override |
| 749 | public EClass getObject() | 782 | public EClass getIfElse() |
| 750 | { | 783 | { |
| 751 | return objectEClass; | 784 | return ifElseEClass; |
| 752 | } | 785 | } |
| 753 | 786 | ||
| 754 | /** | 787 | /** |
| @@ -757,9 +790,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 757 | * @generated | 790 | * @generated |
| 758 | */ | 791 | */ |
| 759 | @Override | 792 | @Override |
| 760 | public EClass getNamedObject() | 793 | public EReference getIfElse_Condition() |
| 761 | { | 794 | { |
| 762 | return namedObjectEClass; | 795 | return (EReference)ifElseEClass.getEStructuralFeatures().get(0); |
| 763 | } | 796 | } |
| 764 | 797 | ||
| 765 | /** | 798 | /** |
| @@ -768,9 +801,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 768 | * @generated | 801 | * @generated |
| 769 | */ | 802 | */ |
| 770 | @Override | 803 | @Override |
| 771 | public EAttribute getNamedObject_Name() | 804 | public EReference getIfElse_Then() |
| 772 | { | 805 | { |
| 773 | return (EAttribute)namedObjectEClass.getEStructuralFeatures().get(0); | 806 | return (EReference)ifElseEClass.getEStructuralFeatures().get(1); |
| 774 | } | 807 | } |
| 775 | 808 | ||
| 776 | /** | 809 | /** |
| @@ -779,9 +812,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 779 | * @generated | 812 | * @generated |
| 780 | */ | 813 | */ |
| 781 | @Override | 814 | @Override |
| 782 | public EClass getUnnamedObject() | 815 | public EReference getIfElse_Else() |
| 783 | { | 816 | { |
| 784 | return unnamedObjectEClass; | 817 | return (EReference)ifElseEClass.getEStructuralFeatures().get(2); |
| 785 | } | 818 | } |
| 786 | 819 | ||
| 787 | /** | 820 | /** |
| @@ -790,9 +823,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 790 | * @generated | 823 | * @generated |
| 791 | */ | 824 | */ |
| 792 | @Override | 825 | @Override |
| 793 | public EAttribute getUnnamedObject_Name() | 826 | public EClass getCase() |
| 794 | { | 827 | { |
| 795 | return (EAttribute)unnamedObjectEClass.getEStructuralFeatures().get(0); | 828 | return caseEClass; |
| 796 | } | 829 | } |
| 797 | 830 | ||
| 798 | /** | 831 | /** |
| @@ -801,9 +834,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 801 | * @generated | 834 | * @generated |
| 802 | */ | 835 | */ |
| 803 | @Override | 836 | @Override |
| 804 | public EClass getDataObject() | 837 | public EReference getCase_Condition() |
| 805 | { | 838 | { |
| 806 | return dataObjectEClass; | 839 | return (EReference)caseEClass.getEStructuralFeatures().get(0); |
| 807 | } | 840 | } |
| 808 | 841 | ||
| 809 | /** | 842 | /** |
| @@ -812,9 +845,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 812 | * @generated | 845 | * @generated |
| 813 | */ | 846 | */ |
| 814 | @Override | 847 | @Override |
| 815 | public EClass getBooleanObject() | 848 | public EReference getCase_Body() |
| 816 | { | 849 | { |
| 817 | return booleanObjectEClass; | 850 | return (EReference)caseEClass.getEStructuralFeatures().get(1); |
| 818 | } | 851 | } |
| 819 | 852 | ||
| 820 | /** | 853 | /** |
| @@ -823,9 +856,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 823 | * @generated | 856 | * @generated |
| 824 | */ | 857 | */ |
| 825 | @Override | 858 | @Override |
| 826 | public EReference getBooleanObject_Value() | 859 | public EClass getCount() |
| 827 | { | 860 | { |
| 828 | return (EReference)booleanObjectEClass.getEStructuralFeatures().get(0); | 861 | return countEClass; |
| 829 | } | 862 | } |
| 830 | 863 | ||
| 831 | /** | 864 | /** |
| @@ -834,9 +867,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 834 | * @generated | 867 | * @generated |
| 835 | */ | 868 | */ |
| 836 | @Override | 869 | @Override |
| 837 | public EClass getIntObject() | 870 | public EReference getCount_Body() |
| 838 | { | 871 | { |
| 839 | return intObjectEClass; | 872 | return (EReference)countEClass.getEStructuralFeatures().get(0); |
| 840 | } | 873 | } |
| 841 | 874 | ||
| 842 | /** | 875 | /** |
| @@ -845,9 +878,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 845 | * @generated | 878 | * @generated |
| 846 | */ | 879 | */ |
| 847 | @Override | 880 | @Override |
| 848 | public EAttribute getIntObject_Value() | 881 | public EClass getAggregation() |
| 849 | { | 882 | { |
| 850 | return (EAttribute)intObjectEClass.getEStructuralFeatures().get(0); | 883 | return aggregationEClass; |
| 851 | } | 884 | } |
| 852 | 885 | ||
| 853 | /** | 886 | /** |
| @@ -856,9 +889,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 856 | * @generated | 889 | * @generated |
| 857 | */ | 890 | */ |
| 858 | @Override | 891 | @Override |
| 859 | public EClass getRealObject() | 892 | public EAttribute getAggregation_Op() |
| 860 | { | 893 | { |
| 861 | return realObjectEClass; | 894 | return (EAttribute)aggregationEClass.getEStructuralFeatures().get(0); |
| 862 | } | 895 | } |
| 863 | 896 | ||
| 864 | /** | 897 | /** |
| @@ -867,9 +900,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 867 | * @generated | 900 | * @generated |
| 868 | */ | 901 | */ |
| 869 | @Override | 902 | @Override |
| 870 | public EAttribute getRealObject_Value() | 903 | public EReference getAggregation_Body() |
| 871 | { | 904 | { |
| 872 | return (EAttribute)realObjectEClass.getEStructuralFeatures().get(0); | 905 | return (EReference)aggregationEClass.getEStructuralFeatures().get(1); |
| 873 | } | 906 | } |
| 874 | 907 | ||
| 875 | /** | 908 | /** |
| @@ -878,9 +911,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 878 | * @generated | 911 | * @generated |
| 879 | */ | 912 | */ |
| 880 | @Override | 913 | @Override |
| 881 | public EClass getStringObject() | 914 | public EReference getAggregation_Condition() |
| 882 | { | 915 | { |
| 883 | return stringObjectEClass; | 916 | return (EReference)aggregationEClass.getEStructuralFeatures().get(2); |
| 884 | } | 917 | } |
| 885 | 918 | ||
| 886 | /** | 919 | /** |
| @@ -889,9 +922,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 889 | * @generated | 922 | * @generated |
| 890 | */ | 923 | */ |
| 891 | @Override | 924 | @Override |
| 892 | public EAttribute getStringObject_Value() | 925 | public EClass getCall() |
| 893 | { | 926 | { |
| 894 | return (EAttribute)stringObjectEClass.getEStructuralFeatures().get(0); | 927 | return callEClass; |
| 895 | } | 928 | } |
| 896 | 929 | ||
| 897 | /** | 930 | /** |
| @@ -900,9 +933,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 900 | * @generated | 933 | * @generated |
| 901 | */ | 934 | */ |
| 902 | @Override | 935 | @Override |
| 903 | public EClass getPredicate() | 936 | public EReference getCall_Functor() |
| 904 | { | 937 | { |
| 905 | return predicateEClass; | 938 | return (EReference)callEClass.getEStructuralFeatures().get(0); |
| 906 | } | 939 | } |
| 907 | 940 | ||
| 908 | /** | 941 | /** |
| @@ -911,9 +944,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 911 | * @generated | 944 | * @generated |
| 912 | */ | 945 | */ |
| 913 | @Override | 946 | @Override |
| 914 | public EAttribute getPredicate_IsError() | 947 | public EAttribute getCall_TransitiveClosure() |
| 915 | { | 948 | { |
| 916 | return (EAttribute)predicateEClass.getEStructuralFeatures().get(0); | 949 | return (EAttribute)callEClass.getEStructuralFeatures().get(1); |
| 917 | } | 950 | } |
| 918 | 951 | ||
| 919 | /** | 952 | /** |
| @@ -922,9 +955,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 922 | * @generated | 955 | * @generated |
| 923 | */ | 956 | */ |
| 924 | @Override | 957 | @Override |
| 925 | public EReference getPredicate_Symbol() | 958 | public EAttribute getCall_ReflexiveTransitiveClosure() |
| 926 | { | 959 | { |
| 927 | return (EReference)predicateEClass.getEStructuralFeatures().get(1); | 960 | return (EAttribute)callEClass.getEStructuralFeatures().get(2); |
| 928 | } | 961 | } |
| 929 | 962 | ||
| 930 | /** | 963 | /** |
| @@ -933,9 +966,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 933 | * @generated | 966 | * @generated |
| 934 | */ | 967 | */ |
| 935 | @Override | 968 | @Override |
| 936 | public EReference getPredicate_Parameters() | 969 | public EReference getCall_ArgumentList() |
| 937 | { | 970 | { |
| 938 | return (EReference)predicateEClass.getEStructuralFeatures().get(2); | 971 | return (EReference)callEClass.getEStructuralFeatures().get(3); |
| 939 | } | 972 | } |
| 940 | 973 | ||
| 941 | /** | 974 | /** |
| @@ -944,9 +977,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 944 | * @generated | 977 | * @generated |
| 945 | */ | 978 | */ |
| 946 | @Override | 979 | @Override |
| 947 | public EReference getPredicate_Bodies() | 980 | public EClass getArgumentList() |
| 948 | { | 981 | { |
| 949 | return (EReference)predicateEClass.getEStructuralFeatures().get(3); | 982 | return argumentListEClass; |
| 950 | } | 983 | } |
| 951 | 984 | ||
| 952 | /** | 985 | /** |
| @@ -955,9 +988,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 955 | * @generated | 988 | * @generated |
| 956 | */ | 989 | */ |
| 957 | @Override | 990 | @Override |
| 958 | public EClass getParameter() | 991 | public EReference getArgumentList_Arguments() |
| 959 | { | 992 | { |
| 960 | return parameterEClass; | 993 | return (EReference)argumentListEClass.getEStructuralFeatures().get(0); |
| 961 | } | 994 | } |
| 962 | 995 | ||
| 963 | /** | 996 | /** |
| @@ -966,9 +999,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 966 | * @generated | 999 | * @generated |
| 967 | */ | 1000 | */ |
| 968 | @Override | 1001 | @Override |
| 969 | public EReference getParameter_Variable() | 1002 | public EClass getArgument() |
| 970 | { | 1003 | { |
| 971 | return (EReference)parameterEClass.getEStructuralFeatures().get(0); | 1004 | return argumentEClass; |
| 972 | } | 1005 | } |
| 973 | 1006 | ||
| 974 | /** | 1007 | /** |
| @@ -977,9 +1010,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 977 | * @generated | 1010 | * @generated |
| 978 | */ | 1011 | */ |
| 979 | @Override | 1012 | @Override |
| 980 | public EReference getParameter_Type() | 1013 | public EClass getExpressionArgument() |
| 981 | { | 1014 | { |
| 982 | return (EReference)parameterEClass.getEStructuralFeatures().get(1); | 1015 | return expressionArgumentEClass; |
| 983 | } | 1016 | } |
| 984 | 1017 | ||
| 985 | /** | 1018 | /** |
| @@ -988,9 +1021,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 988 | * @generated | 1021 | * @generated |
| 989 | */ | 1022 | */ |
| 990 | @Override | 1023 | @Override |
| 991 | public EClass getPatternBody() | 1024 | public EReference getExpressionArgument_Body() |
| 992 | { | 1025 | { |
| 993 | return patternBodyEClass; | 1026 | return (EReference)expressionArgumentEClass.getEStructuralFeatures().get(0); |
| 994 | } | 1027 | } |
| 995 | 1028 | ||
| 996 | /** | 1029 | /** |
| @@ -999,9 +1032,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 999 | * @generated | 1032 | * @generated |
| 1000 | */ | 1033 | */ |
| 1001 | @Override | 1034 | @Override |
| 1002 | public EReference getPatternBody_Constraints() | 1035 | public EClass getStarArgument() |
| 1003 | { | 1036 | { |
| 1004 | return (EReference)patternBodyEClass.getEStructuralFeatures().get(0); | 1037 | return starArgumentEClass; |
| 1005 | } | 1038 | } |
| 1006 | 1039 | ||
| 1007 | /** | 1040 | /** |
| @@ -1010,9 +1043,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1010 | * @generated | 1043 | * @generated |
| 1011 | */ | 1044 | */ |
| 1012 | @Override | 1045 | @Override |
| 1013 | public EClass getPolarity() | 1046 | public EClass getTypedArgument() |
| 1014 | { | 1047 | { |
| 1015 | return polarityEClass; | 1048 | return typedArgumentEClass; |
| 1016 | } | 1049 | } |
| 1017 | 1050 | ||
| 1018 | /** | 1051 | /** |
| @@ -1021,9 +1054,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1021 | * @generated | 1054 | * @generated |
| 1022 | */ | 1055 | */ |
| 1023 | @Override | 1056 | @Override |
| 1024 | public EClass getConstraint() | 1057 | public EReference getTypedArgument_Type() |
| 1025 | { | 1058 | { |
| 1026 | return constraintEClass; | 1059 | return (EReference)typedArgumentEClass.getEStructuralFeatures().get(0); |
| 1027 | } | 1060 | } |
| 1028 | 1061 | ||
| 1029 | /** | 1062 | /** |
| @@ -1032,9 +1065,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1032 | * @generated | 1065 | * @generated |
| 1033 | */ | 1066 | */ |
| 1034 | @Override | 1067 | @Override |
| 1035 | public EReference getConstraint_Polarity() | 1068 | public EReference getTypedArgument_Variable() |
| 1036 | { | 1069 | { |
| 1037 | return (EReference)constraintEClass.getEStructuralFeatures().get(0); | 1070 | return (EReference)typedArgumentEClass.getEStructuralFeatures().get(1); |
| 1038 | } | 1071 | } |
| 1039 | 1072 | ||
| 1040 | /** | 1073 | /** |
| @@ -1043,9 +1076,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1043 | * @generated | 1076 | * @generated |
| 1044 | */ | 1077 | */ |
| 1045 | @Override | 1078 | @Override |
| 1046 | public EReference getConstraint_Symbol() | 1079 | public EClass getTypedStarArgument() |
| 1047 | { | 1080 | { |
| 1048 | return (EReference)constraintEClass.getEStructuralFeatures().get(1); | 1081 | return typedStarArgumentEClass; |
| 1049 | } | 1082 | } |
| 1050 | 1083 | ||
| 1051 | /** | 1084 | /** |
| @@ -1054,9 +1087,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1054 | * @generated | 1087 | * @generated |
| 1055 | */ | 1088 | */ |
| 1056 | @Override | 1089 | @Override |
| 1057 | public EReference getConstraint_Params() | 1090 | public EReference getTypedStarArgument_Type() |
| 1058 | { | 1091 | { |
| 1059 | return (EReference)constraintEClass.getEStructuralFeatures().get(2); | 1092 | return (EReference)typedStarArgumentEClass.getEStructuralFeatures().get(0); |
| 1060 | } | 1093 | } |
| 1061 | 1094 | ||
| 1062 | /** | 1095 | /** |
| @@ -1065,9 +1098,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1065 | * @generated | 1098 | * @generated |
| 1066 | */ | 1099 | */ |
| 1067 | @Override | 1100 | @Override |
| 1068 | public EReference getConstraint_ClosureType() | 1101 | public EClass getReference() |
| 1069 | { | 1102 | { |
| 1070 | return (EReference)constraintEClass.getEStructuralFeatures().get(3); | 1103 | return referenceEClass; |
| 1071 | } | 1104 | } |
| 1072 | 1105 | ||
| 1073 | /** | 1106 | /** |
| @@ -1076,9 +1109,42 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1076 | * @generated | 1109 | * @generated |
| 1077 | */ | 1110 | */ |
| 1078 | @Override | 1111 | @Override |
| 1079 | public EClass getClosureType() | 1112 | public EReference getReference_Referred() |
| 1080 | { | 1113 | { |
| 1081 | return closureTypeEClass; | 1114 | return (EReference)referenceEClass.getEStructuralFeatures().get(0); |
| 1115 | } | ||
| 1116 | |||
| 1117 | /** | ||
| 1118 | * <!-- begin-user-doc --> | ||
| 1119 | * <!-- end-user-doc --> | ||
| 1120 | * @generated | ||
| 1121 | */ | ||
| 1122 | @Override | ||
| 1123 | public EClass getInterval() | ||
| 1124 | { | ||
| 1125 | return intervalEClass; | ||
| 1126 | } | ||
| 1127 | |||
| 1128 | /** | ||
| 1129 | * <!-- begin-user-doc --> | ||
| 1130 | * <!-- end-user-doc --> | ||
| 1131 | * @generated | ||
| 1132 | */ | ||
| 1133 | @Override | ||
| 1134 | public EReference getInterval_LowerBound() | ||
| 1135 | { | ||
| 1136 | return (EReference)intervalEClass.getEStructuralFeatures().get(0); | ||
| 1137 | } | ||
| 1138 | |||
| 1139 | /** | ||
| 1140 | * <!-- begin-user-doc --> | ||
| 1141 | * <!-- end-user-doc --> | ||
| 1142 | * @generated | ||
| 1143 | */ | ||
| 1144 | @Override | ||
| 1145 | public EReference getInterval_UpperBound() | ||
| 1146 | { | ||
| 1147 | return (EReference)intervalEClass.getEStructuralFeatures().get(1); | ||
| 1082 | } | 1148 | } |
| 1083 | 1149 | ||
| 1084 | /** | 1150 | /** |
| @@ -1098,9 +1164,218 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1098 | * @generated | 1164 | * @generated |
| 1099 | */ | 1165 | */ |
| 1100 | @Override | 1166 | @Override |
| 1101 | public EClass getVariable() | 1167 | public EClass getLogicLiteral() |
| 1168 | { | ||
| 1169 | return logicLiteralEClass; | ||
| 1170 | } | ||
| 1171 | |||
| 1172 | /** | ||
| 1173 | * <!-- begin-user-doc --> | ||
| 1174 | * <!-- end-user-doc --> | ||
| 1175 | * @generated | ||
| 1176 | */ | ||
| 1177 | @Override | ||
| 1178 | public EAttribute getLogicLiteral_Value() | ||
| 1179 | { | ||
| 1180 | return (EAttribute)logicLiteralEClass.getEStructuralFeatures().get(0); | ||
| 1181 | } | ||
| 1182 | |||
| 1183 | /** | ||
| 1184 | * <!-- begin-user-doc --> | ||
| 1185 | * <!-- end-user-doc --> | ||
| 1186 | * @generated | ||
| 1187 | */ | ||
| 1188 | @Override | ||
| 1189 | public EClass getNumericLiteral() | ||
| 1190 | { | ||
| 1191 | return numericLiteralEClass; | ||
| 1192 | } | ||
| 1193 | |||
| 1194 | /** | ||
| 1195 | * <!-- begin-user-doc --> | ||
| 1196 | * <!-- end-user-doc --> | ||
| 1197 | * @generated | ||
| 1198 | */ | ||
| 1199 | @Override | ||
| 1200 | public EAttribute getNumericLiteral_Value() | ||
| 1201 | { | ||
| 1202 | return (EAttribute)numericLiteralEClass.getEStructuralFeatures().get(0); | ||
| 1203 | } | ||
| 1204 | |||
| 1205 | /** | ||
| 1206 | * <!-- begin-user-doc --> | ||
| 1207 | * <!-- end-user-doc --> | ||
| 1208 | * @generated | ||
| 1209 | */ | ||
| 1210 | @Override | ||
| 1211 | public EClass getInfinityLiteral() | ||
| 1212 | { | ||
| 1213 | return infinityLiteralEClass; | ||
| 1214 | } | ||
| 1215 | |||
| 1216 | /** | ||
| 1217 | * <!-- begin-user-doc --> | ||
| 1218 | * <!-- end-user-doc --> | ||
| 1219 | * @generated | ||
| 1220 | */ | ||
| 1221 | @Override | ||
| 1222 | public EClass getEmptyIntervalLiteral() | ||
| 1223 | { | ||
| 1224 | return emptyIntervalLiteralEClass; | ||
| 1225 | } | ||
| 1226 | |||
| 1227 | /** | ||
| 1228 | * <!-- begin-user-doc --> | ||
| 1229 | * <!-- end-user-doc --> | ||
| 1230 | * @generated | ||
| 1231 | */ | ||
| 1232 | @Override | ||
| 1233 | public EClass getStringLiteral() | ||
| 1234 | { | ||
| 1235 | return stringLiteralEClass; | ||
| 1236 | } | ||
| 1237 | |||
| 1238 | /** | ||
| 1239 | * <!-- begin-user-doc --> | ||
| 1240 | * <!-- end-user-doc --> | ||
| 1241 | * @generated | ||
| 1242 | */ | ||
| 1243 | @Override | ||
| 1244 | public EAttribute getStringLiteral_Value() | ||
| 1245 | { | ||
| 1246 | return (EAttribute)stringLiteralEClass.getEStructuralFeatures().get(0); | ||
| 1247 | } | ||
| 1248 | |||
| 1249 | /** | ||
| 1250 | * <!-- begin-user-doc --> | ||
| 1251 | * <!-- end-user-doc --> | ||
| 1252 | * @generated | ||
| 1253 | */ | ||
| 1254 | @Override | ||
| 1255 | public EClass getClassDefinition() | ||
| 1256 | { | ||
| 1257 | return classDefinitionEClass; | ||
| 1258 | } | ||
| 1259 | |||
| 1260 | /** | ||
| 1261 | * <!-- begin-user-doc --> | ||
| 1262 | * <!-- end-user-doc --> | ||
| 1263 | * @generated | ||
| 1264 | */ | ||
| 1265 | @Override | ||
| 1266 | public EAttribute getClassDefinition_Abstract() | ||
| 1267 | { | ||
| 1268 | return (EAttribute)classDefinitionEClass.getEStructuralFeatures().get(0); | ||
| 1269 | } | ||
| 1270 | |||
| 1271 | /** | ||
| 1272 | * <!-- begin-user-doc --> | ||
| 1273 | * <!-- end-user-doc --> | ||
| 1274 | * @generated | ||
| 1275 | */ | ||
| 1276 | @Override | ||
| 1277 | public EAttribute getClassDefinition_Name() | ||
| 1278 | { | ||
| 1279 | return (EAttribute)classDefinitionEClass.getEStructuralFeatures().get(1); | ||
| 1280 | } | ||
| 1281 | |||
| 1282 | /** | ||
| 1283 | * <!-- begin-user-doc --> | ||
| 1284 | * <!-- end-user-doc --> | ||
| 1285 | * @generated | ||
| 1286 | */ | ||
| 1287 | @Override | ||
| 1288 | public EReference getClassDefinition_Superclasses() | ||
| 1289 | { | ||
| 1290 | return (EReference)classDefinitionEClass.getEStructuralFeatures().get(2); | ||
| 1291 | } | ||
| 1292 | |||
| 1293 | /** | ||
| 1294 | * <!-- begin-user-doc --> | ||
| 1295 | * <!-- end-user-doc --> | ||
| 1296 | * @generated | ||
| 1297 | */ | ||
| 1298 | @Override | ||
| 1299 | public EReference getClassDefinition_Members() | ||
| 1300 | { | ||
| 1301 | return (EReference)classDefinitionEClass.getEStructuralFeatures().get(3); | ||
| 1302 | } | ||
| 1303 | |||
| 1304 | /** | ||
| 1305 | * <!-- begin-user-doc --> | ||
| 1306 | * <!-- end-user-doc --> | ||
| 1307 | * @generated | ||
| 1308 | */ | ||
| 1309 | @Override | ||
| 1310 | public EClass getMemberDefinition() | ||
| 1311 | { | ||
| 1312 | return memberDefinitionEClass; | ||
| 1313 | } | ||
| 1314 | |||
| 1315 | /** | ||
| 1316 | * <!-- begin-user-doc --> | ||
| 1317 | * <!-- end-user-doc --> | ||
| 1318 | * @generated | ||
| 1319 | */ | ||
| 1320 | @Override | ||
| 1321 | public EAttribute getMemberDefinition_Containment() | ||
| 1322 | { | ||
| 1323 | return (EAttribute)memberDefinitionEClass.getEStructuralFeatures().get(0); | ||
| 1324 | } | ||
| 1325 | |||
| 1326 | /** | ||
| 1327 | * <!-- begin-user-doc --> | ||
| 1328 | * <!-- end-user-doc --> | ||
| 1329 | * @generated | ||
| 1330 | */ | ||
| 1331 | @Override | ||
| 1332 | public EReference getMemberDefinition_Type() | ||
| 1333 | { | ||
| 1334 | return (EReference)memberDefinitionEClass.getEStructuralFeatures().get(1); | ||
| 1335 | } | ||
| 1336 | |||
| 1337 | /** | ||
| 1338 | * <!-- begin-user-doc --> | ||
| 1339 | * <!-- end-user-doc --> | ||
| 1340 | * @generated | ||
| 1341 | */ | ||
| 1342 | @Override | ||
| 1343 | public EReference getMemberDefinition_Multiplicity() | ||
| 1344 | { | ||
| 1345 | return (EReference)memberDefinitionEClass.getEStructuralFeatures().get(2); | ||
| 1346 | } | ||
| 1347 | |||
| 1348 | /** | ||
| 1349 | * <!-- begin-user-doc --> | ||
| 1350 | * <!-- end-user-doc --> | ||
| 1351 | * @generated | ||
| 1352 | */ | ||
| 1353 | @Override | ||
| 1354 | public EAttribute getMemberDefinition_Name() | ||
| 1355 | { | ||
| 1356 | return (EAttribute)memberDefinitionEClass.getEStructuralFeatures().get(3); | ||
| 1357 | } | ||
| 1358 | |||
| 1359 | /** | ||
| 1360 | * <!-- begin-user-doc --> | ||
| 1361 | * <!-- end-user-doc --> | ||
| 1362 | * @generated | ||
| 1363 | */ | ||
| 1364 | @Override | ||
| 1365 | public EReference getMemberDefinition_Opposite() | ||
| 1366 | { | ||
| 1367 | return (EReference)memberDefinitionEClass.getEStructuralFeatures().get(4); | ||
| 1368 | } | ||
| 1369 | |||
| 1370 | /** | ||
| 1371 | * <!-- begin-user-doc --> | ||
| 1372 | * <!-- end-user-doc --> | ||
| 1373 | * @generated | ||
| 1374 | */ | ||
| 1375 | @Override | ||
| 1376 | public EClass getMultiplicity() | ||
| 1102 | { | 1377 | { |
| 1103 | return variableEClass; | 1378 | return multiplicityEClass; |
| 1104 | } | 1379 | } |
| 1105 | 1380 | ||
| 1106 | /** | 1381 | /** |
| @@ -1109,9 +1384,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1109 | * @generated | 1384 | * @generated |
| 1110 | */ | 1385 | */ |
| 1111 | @Override | 1386 | @Override |
| 1112 | public EAttribute getVariable_Name() | 1387 | public EClass getManyMultiplicity() |
| 1113 | { | 1388 | { |
| 1114 | return (EAttribute)variableEClass.getEStructuralFeatures().get(0); | 1389 | return manyMultiplicityEClass; |
| 1115 | } | 1390 | } |
| 1116 | 1391 | ||
| 1117 | /** | 1392 | /** |
| @@ -1120,9 +1395,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1120 | * @generated | 1395 | * @generated |
| 1121 | */ | 1396 | */ |
| 1122 | @Override | 1397 | @Override |
| 1123 | public EClass getAllInstances() | 1398 | public EClass getExactMultiplicity() |
| 1124 | { | 1399 | { |
| 1125 | return allInstancesEClass; | 1400 | return exactMultiplicityEClass; |
| 1126 | } | 1401 | } |
| 1127 | 1402 | ||
| 1128 | /** | 1403 | /** |
| @@ -1131,9 +1406,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1131 | * @generated | 1406 | * @generated |
| 1132 | */ | 1407 | */ |
| 1133 | @Override | 1408 | @Override |
| 1134 | public EReference getAllInstances_Symbol() | 1409 | public EAttribute getExactMultiplicity_Multiplicity() |
| 1135 | { | 1410 | { |
| 1136 | return (EReference)allInstancesEClass.getEStructuralFeatures().get(0); | 1411 | return (EAttribute)exactMultiplicityEClass.getEStructuralFeatures().get(0); |
| 1137 | } | 1412 | } |
| 1138 | 1413 | ||
| 1139 | /** | 1414 | /** |
| @@ -1142,9 +1417,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1142 | * @generated | 1417 | * @generated |
| 1143 | */ | 1418 | */ |
| 1144 | @Override | 1419 | @Override |
| 1145 | public EClass getAllObjects() | 1420 | public EClass getBoundedMultiplicity() |
| 1146 | { | 1421 | { |
| 1147 | return allObjectsEClass; | 1422 | return boundedMultiplicityEClass; |
| 1148 | } | 1423 | } |
| 1149 | 1424 | ||
| 1150 | /** | 1425 | /** |
| @@ -1153,9 +1428,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1153 | * @generated | 1428 | * @generated |
| 1154 | */ | 1429 | */ |
| 1155 | @Override | 1430 | @Override |
| 1156 | public EClass getDefaultInterpretation() | 1431 | public EAttribute getBoundedMultiplicity_LowerBound() |
| 1157 | { | 1432 | { |
| 1158 | return defaultInterpretationEClass; | 1433 | return (EAttribute)boundedMultiplicityEClass.getEStructuralFeatures().get(0); |
| 1159 | } | 1434 | } |
| 1160 | 1435 | ||
| 1161 | /** | 1436 | /** |
| @@ -1164,9 +1439,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1164 | * @generated | 1439 | * @generated |
| 1165 | */ | 1440 | */ |
| 1166 | @Override | 1441 | @Override |
| 1167 | public EReference getDefaultInterpretation_Interpretation() | 1442 | public EAttribute getBoundedMultiplicity_UpperBound() |
| 1168 | { | 1443 | { |
| 1169 | return (EReference)defaultInterpretationEClass.getEStructuralFeatures().get(0); | 1444 | return (EAttribute)boundedMultiplicityEClass.getEStructuralFeatures().get(1); |
| 1170 | } | 1445 | } |
| 1171 | 1446 | ||
| 1172 | /** | 1447 | /** |
| @@ -1175,9 +1450,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1175 | * @generated | 1450 | * @generated |
| 1176 | */ | 1451 | */ |
| 1177 | @Override | 1452 | @Override |
| 1178 | public EClass getCDInterpretation() | 1453 | public EClass getScopeDefinition() |
| 1179 | { | 1454 | { |
| 1180 | return cdInterpretationEClass; | 1455 | return scopeDefinitionEClass; |
| 1181 | } | 1456 | } |
| 1182 | 1457 | ||
| 1183 | /** | 1458 | /** |
| @@ -1186,9 +1461,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1186 | * @generated | 1461 | * @generated |
| 1187 | */ | 1462 | */ |
| 1188 | @Override | 1463 | @Override |
| 1189 | public EClass getClassInterpretation() | 1464 | public EReference getScopeDefinition_Type() |
| 1190 | { | 1465 | { |
| 1191 | return classInterpretationEClass; | 1466 | return (EReference)scopeDefinitionEClass.getEStructuralFeatures().get(0); |
| 1192 | } | 1467 | } |
| 1193 | 1468 | ||
| 1194 | /** | 1469 | /** |
| @@ -1197,9 +1472,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1197 | * @generated | 1472 | * @generated |
| 1198 | */ | 1473 | */ |
| 1199 | @Override | 1474 | @Override |
| 1200 | public EAttribute getClassInterpretation_Abstract() | 1475 | public EClass getExactScopeDefinition() |
| 1201 | { | 1476 | { |
| 1202 | return (EAttribute)classInterpretationEClass.getEStructuralFeatures().get(0); | 1477 | return exactScopeDefinitionEClass; |
| 1203 | } | 1478 | } |
| 1204 | 1479 | ||
| 1205 | /** | 1480 | /** |
| @@ -1208,9 +1483,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1208 | * @generated | 1483 | * @generated |
| 1209 | */ | 1484 | */ |
| 1210 | @Override | 1485 | @Override |
| 1211 | public EReference getClassInterpretation_Symbol() | 1486 | public EAttribute getExactScopeDefinition_ExactScope() |
| 1212 | { | 1487 | { |
| 1213 | return (EReference)classInterpretationEClass.getEStructuralFeatures().get(1); | 1488 | return (EAttribute)exactScopeDefinitionEClass.getEStructuralFeatures().get(0); |
| 1214 | } | 1489 | } |
| 1215 | 1490 | ||
| 1216 | /** | 1491 | /** |
| @@ -1219,9 +1494,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1219 | * @generated | 1494 | * @generated |
| 1220 | */ | 1495 | */ |
| 1221 | @Override | 1496 | @Override |
| 1222 | public EReference getClassInterpretation_Supertypes() | 1497 | public EClass getBoundedScopeDefinition() |
| 1223 | { | 1498 | { |
| 1224 | return (EReference)classInterpretationEClass.getEStructuralFeatures().get(2); | 1499 | return boundedScopeDefinitionEClass; |
| 1225 | } | 1500 | } |
| 1226 | 1501 | ||
| 1227 | /** | 1502 | /** |
| @@ -1230,9 +1505,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1230 | * @generated | 1505 | * @generated |
| 1231 | */ | 1506 | */ |
| 1232 | @Override | 1507 | @Override |
| 1233 | public EReference getClassInterpretation_Fielt() | 1508 | public EAttribute getBoundedScopeDefinition_LowerBound() |
| 1234 | { | 1509 | { |
| 1235 | return (EReference)classInterpretationEClass.getEStructuralFeatures().get(3); | 1510 | return (EAttribute)boundedScopeDefinitionEClass.getEStructuralFeatures().get(0); |
| 1236 | } | 1511 | } |
| 1237 | 1512 | ||
| 1238 | /** | 1513 | /** |
| @@ -1241,9 +1516,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1241 | * @generated | 1516 | * @generated |
| 1242 | */ | 1517 | */ |
| 1243 | @Override | 1518 | @Override |
| 1244 | public EClass getEnumInterpretation() | 1519 | public EAttribute getBoundedScopeDefinition_UpperBound() |
| 1245 | { | 1520 | { |
| 1246 | return enumInterpretationEClass; | 1521 | return (EAttribute)boundedScopeDefinitionEClass.getEStructuralFeatures().get(1); |
| 1247 | } | 1522 | } |
| 1248 | 1523 | ||
| 1249 | /** | 1524 | /** |
| @@ -1252,9 +1527,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1252 | * @generated | 1527 | * @generated |
| 1253 | */ | 1528 | */ |
| 1254 | @Override | 1529 | @Override |
| 1255 | public EReference getEnumInterpretation_Symbol() | 1530 | public EClass getLowerBoundedScopeDefinition() |
| 1256 | { | 1531 | { |
| 1257 | return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(0); | 1532 | return lowerBoundedScopeDefinitionEClass; |
| 1258 | } | 1533 | } |
| 1259 | 1534 | ||
| 1260 | /** | 1535 | /** |
| @@ -1263,9 +1538,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1263 | * @generated | 1538 | * @generated |
| 1264 | */ | 1539 | */ |
| 1265 | @Override | 1540 | @Override |
| 1266 | public EReference getEnumInterpretation_Objects() | 1541 | public EAttribute getLowerBoundedScopeDefinition_LowerBound() |
| 1267 | { | 1542 | { |
| 1268 | return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(1); | 1543 | return (EAttribute)lowerBoundedScopeDefinitionEClass.getEStructuralFeatures().get(0); |
| 1269 | } | 1544 | } |
| 1270 | 1545 | ||
| 1271 | /** | 1546 | /** |
| @@ -1274,9 +1549,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1274 | * @generated | 1549 | * @generated |
| 1275 | */ | 1550 | */ |
| 1276 | @Override | 1551 | @Override |
| 1277 | public EClass getFieldRelationInterpretation() | 1552 | public EClass getObjectiveDefinition() |
| 1278 | { | 1553 | { |
| 1279 | return fieldRelationInterpretationEClass; | 1554 | return objectiveDefinitionEClass; |
| 1280 | } | 1555 | } |
| 1281 | 1556 | ||
| 1282 | /** | 1557 | /** |
| @@ -1285,9 +1560,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1285 | * @generated | 1560 | * @generated |
| 1286 | */ | 1561 | */ |
| 1287 | @Override | 1562 | @Override |
| 1288 | public EAttribute getFieldRelationInterpretation_Containment() | 1563 | public EAttribute getObjectiveDefinition_Kind() |
| 1289 | { | 1564 | { |
| 1290 | return (EAttribute)fieldRelationInterpretationEClass.getEStructuralFeatures().get(0); | 1565 | return (EAttribute)objectiveDefinitionEClass.getEStructuralFeatures().get(0); |
| 1291 | } | 1566 | } |
| 1292 | 1567 | ||
| 1293 | /** | 1568 | /** |
| @@ -1296,9 +1571,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1296 | * @generated | 1571 | * @generated |
| 1297 | */ | 1572 | */ |
| 1298 | @Override | 1573 | @Override |
| 1299 | public EReference getFieldRelationInterpretation_Symbol() | 1574 | public EReference getObjectiveDefinition_Objective() |
| 1300 | { | 1575 | { |
| 1301 | return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(1); | 1576 | return (EReference)objectiveDefinitionEClass.getEStructuralFeatures().get(1); |
| 1302 | } | 1577 | } |
| 1303 | 1578 | ||
| 1304 | /** | 1579 | /** |
| @@ -1307,9 +1582,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1307 | * @generated | 1582 | * @generated |
| 1308 | */ | 1583 | */ |
| 1309 | @Override | 1584 | @Override |
| 1310 | public EReference getFieldRelationInterpretation_Multiplicity() | 1585 | public EClass getNamedElement() |
| 1311 | { | 1586 | { |
| 1312 | return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(2); | 1587 | return namedElementEClass; |
| 1313 | } | 1588 | } |
| 1314 | 1589 | ||
| 1315 | /** | 1590 | /** |
| @@ -1318,9 +1593,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1318 | * @generated | 1593 | * @generated |
| 1319 | */ | 1594 | */ |
| 1320 | @Override | 1595 | @Override |
| 1321 | public EReference getFieldRelationInterpretation_Target() | 1596 | public EAttribute getNamedElement_Name() |
| 1322 | { | 1597 | { |
| 1323 | return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(3); | 1598 | return (EAttribute)namedElementEClass.getEStructuralFeatures().get(0); |
| 1324 | } | 1599 | } |
| 1325 | 1600 | ||
| 1326 | /** | 1601 | /** |
| @@ -1329,9 +1604,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1329 | * @generated | 1604 | * @generated |
| 1330 | */ | 1605 | */ |
| 1331 | @Override | 1606 | @Override |
| 1332 | public EClass getGlobalRelationInterpretation() | 1607 | public EClass getAssertion() |
| 1333 | { | 1608 | { |
| 1334 | return globalRelationInterpretationEClass; | 1609 | return assertionEClass; |
| 1335 | } | 1610 | } |
| 1336 | 1611 | ||
| 1337 | /** | 1612 | /** |
| @@ -1340,9 +1615,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1340 | * @generated | 1615 | * @generated |
| 1341 | */ | 1616 | */ |
| 1342 | @Override | 1617 | @Override |
| 1343 | public EAttribute getGlobalRelationInterpretation_Containment() | 1618 | public EReference getAssertion_Body() |
| 1344 | { | 1619 | { |
| 1345 | return (EAttribute)globalRelationInterpretationEClass.getEStructuralFeatures().get(0); | 1620 | return (EReference)assertionEClass.getEStructuralFeatures().get(0); |
| 1346 | } | 1621 | } |
| 1347 | 1622 | ||
| 1348 | /** | 1623 | /** |
| @@ -1351,9 +1626,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1351 | * @generated | 1626 | * @generated |
| 1352 | */ | 1627 | */ |
| 1353 | @Override | 1628 | @Override |
| 1354 | public EReference getGlobalRelationInterpretation_Symbol() | 1629 | public EReference getAssertion_Range() |
| 1355 | { | 1630 | { |
| 1356 | return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(1); | 1631 | return (EReference)assertionEClass.getEStructuralFeatures().get(1); |
| 1357 | } | 1632 | } |
| 1358 | 1633 | ||
| 1359 | /** | 1634 | /** |
| @@ -1362,9 +1637,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1362 | * @generated | 1637 | * @generated |
| 1363 | */ | 1638 | */ |
| 1364 | @Override | 1639 | @Override |
| 1365 | public EReference getGlobalRelationInterpretation_SourceMultiplicity() | 1640 | public EClass getDisjunction() |
| 1366 | { | 1641 | { |
| 1367 | return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(2); | 1642 | return disjunctionEClass; |
| 1368 | } | 1643 | } |
| 1369 | 1644 | ||
| 1370 | /** | 1645 | /** |
| @@ -1373,9 +1648,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1373 | * @generated | 1648 | * @generated |
| 1374 | */ | 1649 | */ |
| 1375 | @Override | 1650 | @Override |
| 1376 | public EReference getGlobalRelationInterpretation_Source() | 1651 | public EReference getDisjunction_Children() |
| 1377 | { | 1652 | { |
| 1378 | return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(3); | 1653 | return (EReference)disjunctionEClass.getEStructuralFeatures().get(0); |
| 1379 | } | 1654 | } |
| 1380 | 1655 | ||
| 1381 | /** | 1656 | /** |
| @@ -1384,9 +1659,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1384 | * @generated | 1659 | * @generated |
| 1385 | */ | 1660 | */ |
| 1386 | @Override | 1661 | @Override |
| 1387 | public EReference getGlobalRelationInterpretation_TargetMultiplicity() | 1662 | public EClass getSwitch() |
| 1388 | { | 1663 | { |
| 1389 | return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(4); | 1664 | return switchEClass; |
| 1390 | } | 1665 | } |
| 1391 | 1666 | ||
| 1392 | /** | 1667 | /** |
| @@ -1395,9 +1670,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1395 | * @generated | 1670 | * @generated |
| 1396 | */ | 1671 | */ |
| 1397 | @Override | 1672 | @Override |
| 1398 | public EReference getGlobalRelationInterpretation_Target() | 1673 | public EReference getSwitch_Cases() |
| 1399 | { | 1674 | { |
| 1400 | return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(5); | 1675 | return (EReference)switchEClass.getEStructuralFeatures().get(0); |
| 1401 | } | 1676 | } |
| 1402 | 1677 | ||
| 1403 | /** | 1678 | /** |
| @@ -1406,9 +1681,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1406 | * @generated | 1681 | * @generated |
| 1407 | */ | 1682 | */ |
| 1408 | @Override | 1683 | @Override |
| 1409 | public EClass getMultiplicityDefinition() | 1684 | public EClass getConjunction() |
| 1410 | { | 1685 | { |
| 1411 | return multiplicityDefinitionEClass; | 1686 | return conjunctionEClass; |
| 1412 | } | 1687 | } |
| 1413 | 1688 | ||
| 1414 | /** | 1689 | /** |
| @@ -1417,9 +1692,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1417 | * @generated | 1692 | * @generated |
| 1418 | */ | 1693 | */ |
| 1419 | @Override | 1694 | @Override |
| 1420 | public EAttribute getMultiplicityDefinition_Lower() | 1695 | public EReference getConjunction_Children() |
| 1421 | { | 1696 | { |
| 1422 | return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(0); | 1697 | return (EReference)conjunctionEClass.getEStructuralFeatures().get(0); |
| 1423 | } | 1698 | } |
| 1424 | 1699 | ||
| 1425 | /** | 1700 | /** |
| @@ -1428,9 +1703,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1428 | * @generated | 1703 | * @generated |
| 1429 | */ | 1704 | */ |
| 1430 | @Override | 1705 | @Override |
| 1431 | public EAttribute getMultiplicityDefinition_Upper() | 1706 | public EClass getComparison() |
| 1432 | { | 1707 | { |
| 1433 | return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(1); | 1708 | return comparisonEClass; |
| 1434 | } | 1709 | } |
| 1435 | 1710 | ||
| 1436 | /** | 1711 | /** |
| @@ -1439,9 +1714,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1439 | * @generated | 1714 | * @generated |
| 1440 | */ | 1715 | */ |
| 1441 | @Override | 1716 | @Override |
| 1442 | public EAttribute getMultiplicityDefinition_UnlimitedUpper() | 1717 | public EReference getComparison_Left() |
| 1443 | { | 1718 | { |
| 1444 | return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(2); | 1719 | return (EReference)comparisonEClass.getEStructuralFeatures().get(0); |
| 1445 | } | 1720 | } |
| 1446 | 1721 | ||
| 1447 | /** | 1722 | /** |
| @@ -1450,9 +1725,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1450 | * @generated | 1725 | * @generated |
| 1451 | */ | 1726 | */ |
| 1452 | @Override | 1727 | @Override |
| 1453 | public EClass getBooleanTrue() | 1728 | public EAttribute getComparison_Op() |
| 1454 | { | 1729 | { |
| 1455 | return booleanTrueEClass; | 1730 | return (EAttribute)comparisonEClass.getEStructuralFeatures().get(1); |
| 1456 | } | 1731 | } |
| 1457 | 1732 | ||
| 1458 | /** | 1733 | /** |
| @@ -1461,9 +1736,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1461 | * @generated | 1736 | * @generated |
| 1462 | */ | 1737 | */ |
| 1463 | @Override | 1738 | @Override |
| 1464 | public EClass getBooleanFalse() | 1739 | public EReference getComparison_Right() |
| 1465 | { | 1740 | { |
| 1466 | return booleanFalseEClass; | 1741 | return (EReference)comparisonEClass.getEStructuralFeatures().get(2); |
| 1467 | } | 1742 | } |
| 1468 | 1743 | ||
| 1469 | /** | 1744 | /** |
| @@ -1472,9 +1747,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1472 | * @generated | 1747 | * @generated |
| 1473 | */ | 1748 | */ |
| 1474 | @Override | 1749 | @Override |
| 1475 | public EClass getTrue() | 1750 | public EClass getBinaryExpression() |
| 1476 | { | 1751 | { |
| 1477 | return trueEClass; | 1752 | return binaryExpressionEClass; |
| 1478 | } | 1753 | } |
| 1479 | 1754 | ||
| 1480 | /** | 1755 | /** |
| @@ -1483,9 +1758,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1483 | * @generated | 1758 | * @generated |
| 1484 | */ | 1759 | */ |
| 1485 | @Override | 1760 | @Override |
| 1486 | public EClass getFalse() | 1761 | public EReference getBinaryExpression_Left() |
| 1487 | { | 1762 | { |
| 1488 | return falseEClass; | 1763 | return (EReference)binaryExpressionEClass.getEStructuralFeatures().get(0); |
| 1489 | } | 1764 | } |
| 1490 | 1765 | ||
| 1491 | /** | 1766 | /** |
| @@ -1494,9 +1769,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1494 | * @generated | 1769 | * @generated |
| 1495 | */ | 1770 | */ |
| 1496 | @Override | 1771 | @Override |
| 1497 | public EClass getUnknown() | 1772 | public EAttribute getBinaryExpression_Op() |
| 1498 | { | 1773 | { |
| 1499 | return unknownEClass; | 1774 | return (EAttribute)binaryExpressionEClass.getEStructuralFeatures().get(1); |
| 1500 | } | 1775 | } |
| 1501 | 1776 | ||
| 1502 | /** | 1777 | /** |
| @@ -1505,9 +1780,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1505 | * @generated | 1780 | * @generated |
| 1506 | */ | 1781 | */ |
| 1507 | @Override | 1782 | @Override |
| 1508 | public EClass getError() | 1783 | public EReference getBinaryExpression_Right() |
| 1509 | { | 1784 | { |
| 1510 | return errorEClass; | 1785 | return (EReference)binaryExpressionEClass.getEStructuralFeatures().get(2); |
| 1511 | } | 1786 | } |
| 1512 | 1787 | ||
| 1513 | /** | 1788 | /** |
| @@ -1516,9 +1791,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1516 | * @generated | 1791 | * @generated |
| 1517 | */ | 1792 | */ |
| 1518 | @Override | 1793 | @Override |
| 1519 | public EClass getPositive() | 1794 | public EClass getUnaryExpression() |
| 1520 | { | 1795 | { |
| 1521 | return positiveEClass; | 1796 | return unaryExpressionEClass; |
| 1522 | } | 1797 | } |
| 1523 | 1798 | ||
| 1524 | /** | 1799 | /** |
| @@ -1527,9 +1802,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1527 | * @generated | 1802 | * @generated |
| 1528 | */ | 1803 | */ |
| 1529 | @Override | 1804 | @Override |
| 1530 | public EClass getNegative() | 1805 | public EAttribute getUnaryExpression_Op() |
| 1531 | { | 1806 | { |
| 1532 | return negativeEClass; | 1807 | return (EAttribute)unaryExpressionEClass.getEStructuralFeatures().get(0); |
| 1533 | } | 1808 | } |
| 1534 | 1809 | ||
| 1535 | /** | 1810 | /** |
| @@ -1538,9 +1813,9 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1538 | * @generated | 1813 | * @generated |
| 1539 | */ | 1814 | */ |
| 1540 | @Override | 1815 | @Override |
| 1541 | public EClass getReflexiveClosure() | 1816 | public EReference getUnaryExpression_Body() |
| 1542 | { | 1817 | { |
| 1543 | return reflexiveClosureEClass; | 1818 | return (EReference)unaryExpressionEClass.getEStructuralFeatures().get(1); |
| 1544 | } | 1819 | } |
| 1545 | 1820 | ||
| 1546 | /** | 1821 | /** |
| @@ -1549,9 +1824,64 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1549 | * @generated | 1824 | * @generated |
| 1550 | */ | 1825 | */ |
| 1551 | @Override | 1826 | @Override |
| 1552 | public EClass getIrreflexiveClosure() | 1827 | public EEnum getMetricType() |
| 1553 | { | 1828 | { |
| 1554 | return irreflexiveClosureEClass; | 1829 | return metricTypeEEnum; |
| 1830 | } | ||
| 1831 | |||
| 1832 | /** | ||
| 1833 | * <!-- begin-user-doc --> | ||
| 1834 | * <!-- end-user-doc --> | ||
| 1835 | * @generated | ||
| 1836 | */ | ||
| 1837 | @Override | ||
| 1838 | public EEnum getBinaryOperator() | ||
| 1839 | { | ||
| 1840 | return binaryOperatorEEnum; | ||
| 1841 | } | ||
| 1842 | |||
| 1843 | /** | ||
| 1844 | * <!-- begin-user-doc --> | ||
| 1845 | * <!-- end-user-doc --> | ||
| 1846 | * @generated | ||
| 1847 | */ | ||
| 1848 | @Override | ||
| 1849 | public EEnum getUnaryOp() | ||
| 1850 | { | ||
| 1851 | return unaryOpEEnum; | ||
| 1852 | } | ||
| 1853 | |||
| 1854 | /** | ||
| 1855 | * <!-- begin-user-doc --> | ||
| 1856 | * <!-- end-user-doc --> | ||
| 1857 | * @generated | ||
| 1858 | */ | ||
| 1859 | @Override | ||
| 1860 | public EEnum getAggregationOp() | ||
| 1861 | { | ||
| 1862 | return aggregationOpEEnum; | ||
| 1863 | } | ||
| 1864 | |||
| 1865 | /** | ||
| 1866 | * <!-- begin-user-doc --> | ||
| 1867 | * <!-- end-user-doc --> | ||
| 1868 | * @generated | ||
| 1869 | */ | ||
| 1870 | @Override | ||
| 1871 | public EEnum getLogicValue() | ||
| 1872 | { | ||
| 1873 | return logicValueEEnum; | ||
| 1874 | } | ||
| 1875 | |||
| 1876 | /** | ||
| 1877 | * <!-- begin-user-doc --> | ||
| 1878 | * <!-- end-user-doc --> | ||
| 1879 | * @generated | ||
| 1880 | */ | ||
| 1881 | @Override | ||
| 1882 | public EEnum getObjectiveKind() | ||
| 1883 | { | ||
| 1884 | return objectiveKindEEnum; | ||
| 1555 | } | 1885 | } |
| 1556 | 1886 | ||
| 1557 | /** | 1887 | /** |
| @@ -1590,148 +1920,174 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1590 | 1920 | ||
| 1591 | statementEClass = createEClass(STATEMENT); | 1921 | statementEClass = createEClass(STATEMENT); |
| 1592 | 1922 | ||
| 1593 | booleanValueEClass = createEClass(BOOLEAN_VALUE); | 1923 | predicateDefinitionEClass = createEClass(PREDICATE_DEFINITION); |
| 1594 | 1924 | createEReference(predicateDefinitionEClass, PREDICATE_DEFINITION__HEAD); | |
| 1595 | truthValueEClass = createEClass(TRUTH_VALUE); | 1925 | createEReference(predicateDefinitionEClass, PREDICATE_DEFINITION__BODY); |
| 1596 | 1926 | createEAttribute(predicateDefinitionEClass, PREDICATE_DEFINITION__FUNCTIONAL); | |
| 1597 | interpretationEClass = createEClass(INTERPRETATION); | 1927 | createEAttribute(predicateDefinitionEClass, PREDICATE_DEFINITION__ERROR); |
| 1598 | 1928 | ||
| 1599 | basicInterpretationEClass = createEClass(BASIC_INTERPRETATION); | 1929 | unnamedErrorPrediateDefinitionEClass = createEClass(UNNAMED_ERROR_PREDIATE_DEFINITION); |
| 1600 | createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__SYMBOL); | 1930 | createEReference(unnamedErrorPrediateDefinitionEClass, UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST); |
| 1601 | createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__OBJECTS); | 1931 | createEReference(unnamedErrorPrediateDefinitionEClass, UNNAMED_ERROR_PREDIATE_DEFINITION__BODY); |
| 1602 | createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__VALUE); | ||
| 1603 | 1932 | ||
| 1604 | symbolEClass = createEClass(SYMBOL); | 1933 | defaultDefinitionEClass = createEClass(DEFAULT_DEFINITION); |
| 1934 | createEReference(defaultDefinitionEClass, DEFAULT_DEFINITION__HEAD); | ||
| 1935 | createEReference(defaultDefinitionEClass, DEFAULT_DEFINITION__RANGE); | ||
| 1605 | 1936 | ||
| 1606 | modelSymbolEClass = createEClass(MODEL_SYMBOL); | 1937 | externPredicateDefinitionEClass = createEClass(EXTERN_PREDICATE_DEFINITION); |
| 1607 | createEAttribute(modelSymbolEClass, MODEL_SYMBOL__NAME); | 1938 | createEReference(externPredicateDefinitionEClass, EXTERN_PREDICATE_DEFINITION__HEAD); |
| 1608 | 1939 | ||
| 1609 | partialitySymbolEClass = createEClass(PARTIALITY_SYMBOL); | 1940 | metricDefinitionEClass = createEClass(METRIC_DEFINITION); |
| 1941 | createEReference(metricDefinitionEClass, METRIC_DEFINITION__HEAD); | ||
| 1942 | createEReference(metricDefinitionEClass, METRIC_DEFINITION__BODY); | ||
| 1943 | createEAttribute(metricDefinitionEClass, METRIC_DEFINITION__TYPE); | ||
| 1610 | 1944 | ||
| 1611 | existSymbolEClass = createEClass(EXIST_SYMBOL); | 1945 | externMetricDefinitionEClass = createEClass(EXTERN_METRIC_DEFINITION); |
| 1946 | createEAttribute(externMetricDefinitionEClass, EXTERN_METRIC_DEFINITION__TYPE); | ||
| 1947 | createEReference(externMetricDefinitionEClass, EXTERN_METRIC_DEFINITION__HEAD); | ||
| 1612 | 1948 | ||
| 1613 | equalsSymbolEClass = createEClass(EQUALS_SYMBOL); | 1949 | expressionEClass = createEClass(EXPRESSION); |
| 1614 | 1950 | ||
| 1615 | dataSymbolEClass = createEClass(DATA_SYMBOL); | 1951 | ifElseEClass = createEClass(IF_ELSE); |
| 1952 | createEReference(ifElseEClass, IF_ELSE__CONDITION); | ||
| 1953 | createEReference(ifElseEClass, IF_ELSE__THEN); | ||
| 1954 | createEReference(ifElseEClass, IF_ELSE__ELSE); | ||
| 1616 | 1955 | ||
| 1617 | booleanSymbolEClass = createEClass(BOOLEAN_SYMBOL); | 1956 | caseEClass = createEClass(CASE); |
| 1957 | createEReference(caseEClass, CASE__CONDITION); | ||
| 1958 | createEReference(caseEClass, CASE__BODY); | ||
| 1618 | 1959 | ||
| 1619 | integerSymbolEClass = createEClass(INTEGER_SYMBOL); | 1960 | countEClass = createEClass(COUNT); |
| 1961 | createEReference(countEClass, COUNT__BODY); | ||
| 1620 | 1962 | ||
| 1621 | realSymbolEClass = createEClass(REAL_SYMBOL); | 1963 | aggregationEClass = createEClass(AGGREGATION); |
| 1964 | createEAttribute(aggregationEClass, AGGREGATION__OP); | ||
| 1965 | createEReference(aggregationEClass, AGGREGATION__BODY); | ||
| 1966 | createEReference(aggregationEClass, AGGREGATION__CONDITION); | ||
| 1622 | 1967 | ||
| 1623 | stringSymbolEClass = createEClass(STRING_SYMBOL); | 1968 | callEClass = createEClass(CALL); |
| 1969 | createEReference(callEClass, CALL__FUNCTOR); | ||
| 1970 | createEAttribute(callEClass, CALL__TRANSITIVE_CLOSURE); | ||
| 1971 | createEAttribute(callEClass, CALL__REFLEXIVE_TRANSITIVE_CLOSURE); | ||
| 1972 | createEReference(callEClass, CALL__ARGUMENT_LIST); | ||
| 1624 | 1973 | ||
| 1625 | complexObjectEClass = createEClass(COMPLEX_OBJECT); | 1974 | argumentListEClass = createEClass(ARGUMENT_LIST); |
| 1975 | createEReference(argumentListEClass, ARGUMENT_LIST__ARGUMENTS); | ||
| 1626 | 1976 | ||
| 1627 | objectEClass = createEClass(OBJECT); | 1977 | argumentEClass = createEClass(ARGUMENT); |
| 1628 | 1978 | ||
| 1629 | namedObjectEClass = createEClass(NAMED_OBJECT); | 1979 | expressionArgumentEClass = createEClass(EXPRESSION_ARGUMENT); |
| 1630 | createEAttribute(namedObjectEClass, NAMED_OBJECT__NAME); | 1980 | createEReference(expressionArgumentEClass, EXPRESSION_ARGUMENT__BODY); |
| 1631 | 1981 | ||
| 1632 | unnamedObjectEClass = createEClass(UNNAMED_OBJECT); | 1982 | starArgumentEClass = createEClass(STAR_ARGUMENT); |
| 1633 | createEAttribute(unnamedObjectEClass, UNNAMED_OBJECT__NAME); | ||
| 1634 | 1983 | ||
| 1635 | dataObjectEClass = createEClass(DATA_OBJECT); | 1984 | typedArgumentEClass = createEClass(TYPED_ARGUMENT); |
| 1985 | createEReference(typedArgumentEClass, TYPED_ARGUMENT__TYPE); | ||
| 1986 | createEReference(typedArgumentEClass, TYPED_ARGUMENT__VARIABLE); | ||
| 1636 | 1987 | ||
| 1637 | booleanObjectEClass = createEClass(BOOLEAN_OBJECT); | 1988 | typedStarArgumentEClass = createEClass(TYPED_STAR_ARGUMENT); |
| 1638 | createEReference(booleanObjectEClass, BOOLEAN_OBJECT__VALUE); | 1989 | createEReference(typedStarArgumentEClass, TYPED_STAR_ARGUMENT__TYPE); |
| 1639 | 1990 | ||
| 1640 | intObjectEClass = createEClass(INT_OBJECT); | 1991 | referenceEClass = createEClass(REFERENCE); |
| 1641 | createEAttribute(intObjectEClass, INT_OBJECT__VALUE); | 1992 | createEReference(referenceEClass, REFERENCE__REFERRED); |
| 1642 | 1993 | ||
| 1643 | realObjectEClass = createEClass(REAL_OBJECT); | 1994 | intervalEClass = createEClass(INTERVAL); |
| 1644 | createEAttribute(realObjectEClass, REAL_OBJECT__VALUE); | 1995 | createEReference(intervalEClass, INTERVAL__LOWER_BOUND); |
| 1996 | createEReference(intervalEClass, INTERVAL__UPPER_BOUND); | ||
| 1645 | 1997 | ||
| 1646 | stringObjectEClass = createEClass(STRING_OBJECT); | 1998 | literalEClass = createEClass(LITERAL); |
| 1647 | createEAttribute(stringObjectEClass, STRING_OBJECT__VALUE); | ||
| 1648 | |||
| 1649 | predicateEClass = createEClass(PREDICATE); | ||
| 1650 | createEAttribute(predicateEClass, PREDICATE__IS_ERROR); | ||
| 1651 | createEReference(predicateEClass, PREDICATE__SYMBOL); | ||
| 1652 | createEReference(predicateEClass, PREDICATE__PARAMETERS); | ||
| 1653 | createEReference(predicateEClass, PREDICATE__BODIES); | ||
| 1654 | 1999 | ||
| 1655 | parameterEClass = createEClass(PARAMETER); | 2000 | logicLiteralEClass = createEClass(LOGIC_LITERAL); |
| 1656 | createEReference(parameterEClass, PARAMETER__VARIABLE); | 2001 | createEAttribute(logicLiteralEClass, LOGIC_LITERAL__VALUE); |
| 1657 | createEReference(parameterEClass, PARAMETER__TYPE); | ||
| 1658 | 2002 | ||
| 1659 | patternBodyEClass = createEClass(PATTERN_BODY); | 2003 | numericLiteralEClass = createEClass(NUMERIC_LITERAL); |
| 1660 | createEReference(patternBodyEClass, PATTERN_BODY__CONSTRAINTS); | 2004 | createEAttribute(numericLiteralEClass, NUMERIC_LITERAL__VALUE); |
| 1661 | 2005 | ||
| 1662 | polarityEClass = createEClass(POLARITY); | 2006 | infinityLiteralEClass = createEClass(INFINITY_LITERAL); |
| 1663 | 2007 | ||
| 1664 | constraintEClass = createEClass(CONSTRAINT); | 2008 | emptyIntervalLiteralEClass = createEClass(EMPTY_INTERVAL_LITERAL); |
| 1665 | createEReference(constraintEClass, CONSTRAINT__POLARITY); | ||
| 1666 | createEReference(constraintEClass, CONSTRAINT__SYMBOL); | ||
| 1667 | createEReference(constraintEClass, CONSTRAINT__PARAMS); | ||
| 1668 | createEReference(constraintEClass, CONSTRAINT__CLOSURE_TYPE); | ||
| 1669 | 2009 | ||
| 1670 | closureTypeEClass = createEClass(CLOSURE_TYPE); | 2010 | stringLiteralEClass = createEClass(STRING_LITERAL); |
| 2011 | createEAttribute(stringLiteralEClass, STRING_LITERAL__VALUE); | ||
| 1671 | 2012 | ||
| 1672 | literalEClass = createEClass(LITERAL); | 2013 | classDefinitionEClass = createEClass(CLASS_DEFINITION); |
| 2014 | createEAttribute(classDefinitionEClass, CLASS_DEFINITION__ABSTRACT); | ||
| 2015 | createEAttribute(classDefinitionEClass, CLASS_DEFINITION__NAME); | ||
| 2016 | createEReference(classDefinitionEClass, CLASS_DEFINITION__SUPERCLASSES); | ||
| 2017 | createEReference(classDefinitionEClass, CLASS_DEFINITION__MEMBERS); | ||
| 1673 | 2018 | ||
| 1674 | variableEClass = createEClass(VARIABLE); | 2019 | memberDefinitionEClass = createEClass(MEMBER_DEFINITION); |
| 1675 | createEAttribute(variableEClass, VARIABLE__NAME); | 2020 | createEAttribute(memberDefinitionEClass, MEMBER_DEFINITION__CONTAINMENT); |
| 2021 | createEReference(memberDefinitionEClass, MEMBER_DEFINITION__TYPE); | ||
| 2022 | createEReference(memberDefinitionEClass, MEMBER_DEFINITION__MULTIPLICITY); | ||
| 2023 | createEAttribute(memberDefinitionEClass, MEMBER_DEFINITION__NAME); | ||
| 2024 | createEReference(memberDefinitionEClass, MEMBER_DEFINITION__OPPOSITE); | ||
| 1676 | 2025 | ||
| 1677 | allInstancesEClass = createEClass(ALL_INSTANCES); | 2026 | multiplicityEClass = createEClass(MULTIPLICITY); |
| 1678 | createEReference(allInstancesEClass, ALL_INSTANCES__SYMBOL); | ||
| 1679 | 2027 | ||
| 1680 | allObjectsEClass = createEClass(ALL_OBJECTS); | 2028 | manyMultiplicityEClass = createEClass(MANY_MULTIPLICITY); |
| 1681 | 2029 | ||
| 1682 | defaultInterpretationEClass = createEClass(DEFAULT_INTERPRETATION); | 2030 | exactMultiplicityEClass = createEClass(EXACT_MULTIPLICITY); |
| 1683 | createEReference(defaultInterpretationEClass, DEFAULT_INTERPRETATION__INTERPRETATION); | 2031 | createEAttribute(exactMultiplicityEClass, EXACT_MULTIPLICITY__MULTIPLICITY); |
| 1684 | 2032 | ||
| 1685 | cdInterpretationEClass = createEClass(CD_INTERPRETATION); | 2033 | boundedMultiplicityEClass = createEClass(BOUNDED_MULTIPLICITY); |
| 2034 | createEAttribute(boundedMultiplicityEClass, BOUNDED_MULTIPLICITY__LOWER_BOUND); | ||
| 2035 | createEAttribute(boundedMultiplicityEClass, BOUNDED_MULTIPLICITY__UPPER_BOUND); | ||
| 1686 | 2036 | ||
| 1687 | classInterpretationEClass = createEClass(CLASS_INTERPRETATION); | 2037 | scopeDefinitionEClass = createEClass(SCOPE_DEFINITION); |
| 1688 | createEAttribute(classInterpretationEClass, CLASS_INTERPRETATION__ABSTRACT); | 2038 | createEReference(scopeDefinitionEClass, SCOPE_DEFINITION__TYPE); |
| 1689 | createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SYMBOL); | ||
| 1690 | createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SUPERTYPES); | ||
| 1691 | createEReference(classInterpretationEClass, CLASS_INTERPRETATION__FIELT); | ||
| 1692 | 2039 | ||
| 1693 | enumInterpretationEClass = createEClass(ENUM_INTERPRETATION); | 2040 | exactScopeDefinitionEClass = createEClass(EXACT_SCOPE_DEFINITION); |
| 1694 | createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__SYMBOL); | 2041 | createEAttribute(exactScopeDefinitionEClass, EXACT_SCOPE_DEFINITION__EXACT_SCOPE); |
| 1695 | createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__OBJECTS); | ||
| 1696 | 2042 | ||
| 1697 | fieldRelationInterpretationEClass = createEClass(FIELD_RELATION_INTERPRETATION); | 2043 | boundedScopeDefinitionEClass = createEClass(BOUNDED_SCOPE_DEFINITION); |
| 1698 | createEAttribute(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__CONTAINMENT); | 2044 | createEAttribute(boundedScopeDefinitionEClass, BOUNDED_SCOPE_DEFINITION__LOWER_BOUND); |
| 1699 | createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__SYMBOL); | 2045 | createEAttribute(boundedScopeDefinitionEClass, BOUNDED_SCOPE_DEFINITION__UPPER_BOUND); |
| 1700 | createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__MULTIPLICITY); | ||
| 1701 | createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__TARGET); | ||
| 1702 | 2046 | ||
| 1703 | globalRelationInterpretationEClass = createEClass(GLOBAL_RELATION_INTERPRETATION); | 2047 | lowerBoundedScopeDefinitionEClass = createEClass(LOWER_BOUNDED_SCOPE_DEFINITION); |
| 1704 | createEAttribute(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__CONTAINMENT); | 2048 | createEAttribute(lowerBoundedScopeDefinitionEClass, LOWER_BOUNDED_SCOPE_DEFINITION__LOWER_BOUND); |
| 1705 | createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SYMBOL); | ||
| 1706 | createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY); | ||
| 1707 | createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE); | ||
| 1708 | createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY); | ||
| 1709 | createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET); | ||
| 1710 | 2049 | ||
| 1711 | multiplicityDefinitionEClass = createEClass(MULTIPLICITY_DEFINITION); | 2050 | objectiveDefinitionEClass = createEClass(OBJECTIVE_DEFINITION); |
| 1712 | createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__LOWER); | 2051 | createEAttribute(objectiveDefinitionEClass, OBJECTIVE_DEFINITION__KIND); |
| 1713 | createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UPPER); | 2052 | createEReference(objectiveDefinitionEClass, OBJECTIVE_DEFINITION__OBJECTIVE); |
| 1714 | createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UNLIMITED_UPPER); | ||
| 1715 | 2053 | ||
| 1716 | booleanTrueEClass = createEClass(BOOLEAN_TRUE); | 2054 | namedElementEClass = createEClass(NAMED_ELEMENT); |
| 2055 | createEAttribute(namedElementEClass, NAMED_ELEMENT__NAME); | ||
| 1717 | 2056 | ||
| 1718 | booleanFalseEClass = createEClass(BOOLEAN_FALSE); | 2057 | assertionEClass = createEClass(ASSERTION); |
| 2058 | createEReference(assertionEClass, ASSERTION__BODY); | ||
| 2059 | createEReference(assertionEClass, ASSERTION__RANGE); | ||
| 1719 | 2060 | ||
| 1720 | trueEClass = createEClass(TRUE); | 2061 | disjunctionEClass = createEClass(DISJUNCTION); |
| 2062 | createEReference(disjunctionEClass, DISJUNCTION__CHILDREN); | ||
| 1721 | 2063 | ||
| 1722 | falseEClass = createEClass(FALSE); | 2064 | switchEClass = createEClass(SWITCH); |
| 2065 | createEReference(switchEClass, SWITCH__CASES); | ||
| 1723 | 2066 | ||
| 1724 | unknownEClass = createEClass(UNKNOWN); | 2067 | conjunctionEClass = createEClass(CONJUNCTION); |
| 2068 | createEReference(conjunctionEClass, CONJUNCTION__CHILDREN); | ||
| 1725 | 2069 | ||
| 1726 | errorEClass = createEClass(ERROR); | 2070 | comparisonEClass = createEClass(COMPARISON); |
| 2071 | createEReference(comparisonEClass, COMPARISON__LEFT); | ||
| 2072 | createEAttribute(comparisonEClass, COMPARISON__OP); | ||
| 2073 | createEReference(comparisonEClass, COMPARISON__RIGHT); | ||
| 1727 | 2074 | ||
| 1728 | positiveEClass = createEClass(POSITIVE); | 2075 | binaryExpressionEClass = createEClass(BINARY_EXPRESSION); |
| 2076 | createEReference(binaryExpressionEClass, BINARY_EXPRESSION__LEFT); | ||
| 2077 | createEAttribute(binaryExpressionEClass, BINARY_EXPRESSION__OP); | ||
| 2078 | createEReference(binaryExpressionEClass, BINARY_EXPRESSION__RIGHT); | ||
| 1729 | 2079 | ||
| 1730 | negativeEClass = createEClass(NEGATIVE); | 2080 | unaryExpressionEClass = createEClass(UNARY_EXPRESSION); |
| 2081 | createEAttribute(unaryExpressionEClass, UNARY_EXPRESSION__OP); | ||
| 2082 | createEReference(unaryExpressionEClass, UNARY_EXPRESSION__BODY); | ||
| 1731 | 2083 | ||
| 1732 | reflexiveClosureEClass = createEClass(REFLEXIVE_CLOSURE); | 2084 | // Create enums |
| 1733 | 2085 | metricTypeEEnum = createEEnum(METRIC_TYPE); | |
| 1734 | irreflexiveClosureEClass = createEClass(IRREFLEXIVE_CLOSURE); | 2086 | binaryOperatorEEnum = createEEnum(BINARY_OPERATOR); |
| 2087 | unaryOpEEnum = createEEnum(UNARY_OP); | ||
| 2088 | aggregationOpEEnum = createEEnum(AGGREGATION_OP); | ||
| 2089 | logicValueEEnum = createEEnum(LOGIC_VALUE); | ||
| 2090 | objectiveKindEEnum = createEEnum(OBJECTIVE_KIND); | ||
| 1735 | } | 2091 | } |
| 1736 | 2092 | ||
| 1737 | /** | 2093 | /** |
| @@ -1763,46 +2119,46 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1763 | // Set bounds for type parameters | 2119 | // Set bounds for type parameters |
| 1764 | 2120 | ||
| 1765 | // Add supertypes to classes | 2121 | // Add supertypes to classes |
| 1766 | interpretationEClass.getESuperTypes().add(this.getStatement()); | 2122 | predicateDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1767 | basicInterpretationEClass.getESuperTypes().add(this.getInterpretation()); | 2123 | unnamedErrorPrediateDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1768 | modelSymbolEClass.getESuperTypes().add(this.getSymbol()); | 2124 | defaultDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1769 | partialitySymbolEClass.getESuperTypes().add(this.getSymbol()); | 2125 | externPredicateDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1770 | existSymbolEClass.getESuperTypes().add(this.getPartialitySymbol()); | 2126 | metricDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1771 | equalsSymbolEClass.getESuperTypes().add(this.getPartialitySymbol()); | 2127 | externMetricDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1772 | dataSymbolEClass.getESuperTypes().add(this.getSymbol()); | 2128 | expressionEClass.getESuperTypes().add(this.getStatement()); |
| 1773 | booleanSymbolEClass.getESuperTypes().add(this.getDataSymbol()); | 2129 | ifElseEClass.getESuperTypes().add(this.getExpression()); |
| 1774 | integerSymbolEClass.getESuperTypes().add(this.getDataSymbol()); | 2130 | caseEClass.getESuperTypes().add(this.getExpression()); |
| 1775 | realSymbolEClass.getESuperTypes().add(this.getDataSymbol()); | 2131 | countEClass.getESuperTypes().add(this.getExpression()); |
| 1776 | stringSymbolEClass.getESuperTypes().add(this.getDataSymbol()); | 2132 | aggregationEClass.getESuperTypes().add(this.getExpression()); |
| 1777 | objectEClass.getESuperTypes().add(this.getComplexObject()); | 2133 | callEClass.getESuperTypes().add(this.getExpression()); |
| 1778 | namedObjectEClass.getESuperTypes().add(this.getObject()); | 2134 | expressionArgumentEClass.getESuperTypes().add(this.getArgument()); |
| 1779 | namedObjectEClass.getESuperTypes().add(this.getLiteral()); | 2135 | starArgumentEClass.getESuperTypes().add(this.getArgument()); |
| 1780 | unnamedObjectEClass.getESuperTypes().add(this.getObject()); | 2136 | typedArgumentEClass.getESuperTypes().add(this.getArgument()); |
| 1781 | dataObjectEClass.getESuperTypes().add(this.getObject()); | 2137 | typedStarArgumentEClass.getESuperTypes().add(this.getArgument()); |
| 1782 | dataObjectEClass.getESuperTypes().add(this.getLiteral()); | 2138 | referenceEClass.getESuperTypes().add(this.getExpression()); |
| 1783 | booleanObjectEClass.getESuperTypes().add(this.getDataObject()); | 2139 | intervalEClass.getESuperTypes().add(this.getExpression()); |
| 1784 | intObjectEClass.getESuperTypes().add(this.getDataObject()); | 2140 | literalEClass.getESuperTypes().add(this.getExpression()); |
| 1785 | realObjectEClass.getESuperTypes().add(this.getDataObject()); | 2141 | logicLiteralEClass.getESuperTypes().add(this.getLiteral()); |
| 1786 | stringObjectEClass.getESuperTypes().add(this.getDataObject()); | 2142 | numericLiteralEClass.getESuperTypes().add(this.getLiteral()); |
| 1787 | predicateEClass.getESuperTypes().add(this.getStatement()); | 2143 | infinityLiteralEClass.getESuperTypes().add(this.getLiteral()); |
| 1788 | variableEClass.getESuperTypes().add(this.getLiteral()); | 2144 | emptyIntervalLiteralEClass.getESuperTypes().add(this.getLiteral()); |
| 1789 | allInstancesEClass.getESuperTypes().add(this.getComplexObject()); | 2145 | stringLiteralEClass.getESuperTypes().add(this.getLiteral()); |
| 1790 | allObjectsEClass.getESuperTypes().add(this.getComplexObject()); | 2146 | classDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1791 | defaultInterpretationEClass.getESuperTypes().add(this.getInterpretation()); | 2147 | manyMultiplicityEClass.getESuperTypes().add(this.getMultiplicity()); |
| 1792 | cdInterpretationEClass.getESuperTypes().add(this.getInterpretation()); | 2148 | exactMultiplicityEClass.getESuperTypes().add(this.getMultiplicity()); |
| 1793 | classInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); | 2149 | boundedMultiplicityEClass.getESuperTypes().add(this.getMultiplicity()); |
| 1794 | enumInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); | 2150 | scopeDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1795 | globalRelationInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); | 2151 | exactScopeDefinitionEClass.getESuperTypes().add(this.getScopeDefinition()); |
| 1796 | booleanTrueEClass.getESuperTypes().add(this.getBooleanValue()); | 2152 | boundedScopeDefinitionEClass.getESuperTypes().add(this.getScopeDefinition()); |
| 1797 | booleanFalseEClass.getESuperTypes().add(this.getBooleanValue()); | 2153 | lowerBoundedScopeDefinitionEClass.getESuperTypes().add(this.getScopeDefinition()); |
| 1798 | trueEClass.getESuperTypes().add(this.getTruthValue()); | 2154 | objectiveDefinitionEClass.getESuperTypes().add(this.getStatement()); |
| 1799 | falseEClass.getESuperTypes().add(this.getTruthValue()); | 2155 | assertionEClass.getESuperTypes().add(this.getStatement()); |
| 1800 | unknownEClass.getESuperTypes().add(this.getTruthValue()); | 2156 | disjunctionEClass.getESuperTypes().add(this.getExpression()); |
| 1801 | errorEClass.getESuperTypes().add(this.getTruthValue()); | 2157 | switchEClass.getESuperTypes().add(this.getExpression()); |
| 1802 | positiveEClass.getESuperTypes().add(this.getPolarity()); | 2158 | conjunctionEClass.getESuperTypes().add(this.getExpression()); |
| 1803 | negativeEClass.getESuperTypes().add(this.getPolarity()); | 2159 | comparisonEClass.getESuperTypes().add(this.getExpression()); |
| 1804 | reflexiveClosureEClass.getESuperTypes().add(this.getClosureType()); | 2160 | binaryExpressionEClass.getESuperTypes().add(this.getExpression()); |
| 1805 | irreflexiveClosureEClass.getESuperTypes().add(this.getClosureType()); | 2161 | unaryExpressionEClass.getESuperTypes().add(this.getExpression()); |
| 1806 | 2162 | ||
| 1807 | // Initialize classes and features; add operations and parameters | 2163 | // Initialize classes and features; add operations and parameters |
| 1808 | initEClass(problemEClass, Problem.class, "Problem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2164 | initEClass(problemEClass, Problem.class, "Problem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| @@ -1810,148 +2166,211 @@ public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLan | |||
| 1810 | 2166 | ||
| 1811 | initEClass(statementEClass, Statement.class, "Statement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2167 | initEClass(statementEClass, Statement.class, "Statement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1812 | 2168 | ||
| 1813 | initEClass(booleanValueEClass, BooleanValue.class, "BooleanValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2169 | initEClass(predicateDefinitionEClass, PredicateDefinition.class, "PredicateDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1814 | 2170 | initEReference(getPredicateDefinition_Head(), this.getExpression(), null, "head", null, 0, 1, PredicateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | |
| 1815 | initEClass(truthValueEClass, TruthValue.class, "TruthValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2171 | initEReference(getPredicateDefinition_Body(), this.getExpression(), null, "body", null, 0, 1, PredicateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1816 | 2172 | initEAttribute(getPredicateDefinition_Functional(), ecorePackage.getEBoolean(), "functional", null, 0, 1, PredicateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | |
| 1817 | initEClass(interpretationEClass, Interpretation.class, "Interpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2173 | initEAttribute(getPredicateDefinition_Error(), ecorePackage.getEBoolean(), "error", null, 0, 1, PredicateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1818 | |||
| 1819 | initEClass(basicInterpretationEClass, BasicInterpretation.class, "BasicInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1820 | initEReference(getBasicInterpretation_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1821 | initEReference(getBasicInterpretation_Objects(), this.getComplexObject(), null, "objects", null, 0, -1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1822 | initEReference(getBasicInterpretation_Value(), this.getTruthValue(), null, "value", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1823 | |||
| 1824 | initEClass(symbolEClass, Symbol.class, "Symbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1825 | |||
| 1826 | initEClass(modelSymbolEClass, ModelSymbol.class, "ModelSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1827 | initEAttribute(getModelSymbol_Name(), ecorePackage.getEString(), "name", null, 0, 1, ModelSymbol.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1828 | 2174 | ||
| 1829 | initEClass(partialitySymbolEClass, PartialitySymbol.class, "PartialitySymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2175 | initEClass(unnamedErrorPrediateDefinitionEClass, UnnamedErrorPrediateDefinition.class, "UnnamedErrorPrediateDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2176 | initEReference(getUnnamedErrorPrediateDefinition_ArgumentList(), this.getArgumentList(), null, "argumentList", null, 0, 1, UnnamedErrorPrediateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2177 | initEReference(getUnnamedErrorPrediateDefinition_Body(), this.getExpression(), null, "body", null, 0, 1, UnnamedErrorPrediateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1830 | 2178 | ||
| 1831 | initEClass(existSymbolEClass, ExistSymbol.class, "ExistSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2179 | initEClass(defaultDefinitionEClass, DefaultDefinition.class, "DefaultDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2180 | initEReference(getDefaultDefinition_Head(), this.getCall(), null, "head", null, 0, 1, DefaultDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2181 | initEReference(getDefaultDefinition_Range(), this.getExpression(), null, "range", null, 0, 1, DefaultDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1832 | 2182 | ||
| 1833 | initEClass(equalsSymbolEClass, EqualsSymbol.class, "EqualsSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2183 | initEClass(externPredicateDefinitionEClass, ExternPredicateDefinition.class, "ExternPredicateDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2184 | initEReference(getExternPredicateDefinition_Head(), this.getCall(), null, "head", null, 0, 1, ExternPredicateDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1834 | 2185 | ||
| 1835 | initEClass(dataSymbolEClass, DataSymbol.class, "DataSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2186 | initEClass(metricDefinitionEClass, MetricDefinition.class, "MetricDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2187 | initEReference(getMetricDefinition_Head(), this.getExpression(), null, "head", null, 0, 1, MetricDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2188 | initEReference(getMetricDefinition_Body(), this.getExpression(), null, "body", null, 0, 1, MetricDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2189 | initEAttribute(getMetricDefinition_Type(), this.getMetricType(), "type", null, 0, 1, MetricDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1836 | 2190 | ||
| 1837 | initEClass(booleanSymbolEClass, BooleanSymbol.class, "BooleanSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2191 | initEClass(externMetricDefinitionEClass, ExternMetricDefinition.class, "ExternMetricDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2192 | initEAttribute(getExternMetricDefinition_Type(), this.getMetricType(), "type", null, 0, 1, ExternMetricDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2193 | initEReference(getExternMetricDefinition_Head(), this.getCall(), null, "head", null, 0, 1, ExternMetricDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1838 | 2194 | ||
| 1839 | initEClass(integerSymbolEClass, IntegerSymbol.class, "IntegerSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2195 | initEClass(expressionEClass, Expression.class, "Expression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1840 | 2196 | ||
| 1841 | initEClass(realSymbolEClass, RealSymbol.class, "RealSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2197 | initEClass(ifElseEClass, IfElse.class, "IfElse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2198 | initEReference(getIfElse_Condition(), this.getExpression(), null, "condition", null, 0, 1, IfElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2199 | initEReference(getIfElse_Then(), this.getExpression(), null, "then", null, 0, 1, IfElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2200 | initEReference(getIfElse_Else(), this.getExpression(), null, "else", null, 0, 1, IfElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1842 | 2201 | ||
| 1843 | initEClass(stringSymbolEClass, StringSymbol.class, "StringSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2202 | initEClass(caseEClass, Case.class, "Case", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2203 | initEReference(getCase_Condition(), this.getExpression(), null, "condition", null, 0, 1, Case.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2204 | initEReference(getCase_Body(), this.getExpression(), null, "body", null, 0, 1, Case.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1844 | 2205 | ||
| 1845 | initEClass(complexObjectEClass, ComplexObject.class, "ComplexObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2206 | initEClass(countEClass, Count.class, "Count", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2207 | initEReference(getCount_Body(), this.getExpression(), null, "body", null, 0, 1, Count.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1846 | 2208 | ||
| 1847 | initEClass(objectEClass, org.eclipse.viatra.solver.language.solverLanguage.Object.class, "Object", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2209 | initEClass(aggregationEClass, Aggregation.class, "Aggregation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2210 | initEAttribute(getAggregation_Op(), this.getAggregationOp(), "op", null, 0, 1, Aggregation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2211 | initEReference(getAggregation_Body(), this.getExpression(), null, "body", null, 0, 1, Aggregation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2212 | initEReference(getAggregation_Condition(), this.getExpression(), null, "condition", null, 0, 1, Aggregation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1848 | 2213 | ||
| 1849 | initEClass(namedObjectEClass, NamedObject.class, "NamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2214 | initEClass(callEClass, Call.class, "Call", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1850 | initEAttribute(getNamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, NamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2215 | initEReference(getCall_Functor(), this.getReference(), null, "functor", null, 0, 1, Call.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 2216 | initEAttribute(getCall_TransitiveClosure(), ecorePackage.getEBoolean(), "transitiveClosure", null, 0, 1, Call.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2217 | initEAttribute(getCall_ReflexiveTransitiveClosure(), ecorePackage.getEBoolean(), "reflexiveTransitiveClosure", null, 0, 1, Call.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2218 | initEReference(getCall_ArgumentList(), this.getArgumentList(), null, "argumentList", null, 0, 1, Call.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1851 | 2219 | ||
| 1852 | initEClass(unnamedObjectEClass, UnnamedObject.class, "UnnamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2220 | initEClass(argumentListEClass, ArgumentList.class, "ArgumentList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1853 | initEAttribute(getUnnamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, UnnamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2221 | initEReference(getArgumentList_Arguments(), this.getArgument(), null, "arguments", null, 0, -1, ArgumentList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1854 | 2222 | ||
| 1855 | initEClass(dataObjectEClass, DataObject.class, "DataObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2223 | initEClass(argumentEClass, Argument.class, "Argument", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1856 | 2224 | ||
| 1857 | initEClass(booleanObjectEClass, BooleanObject.class, "BooleanObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2225 | initEClass(expressionArgumentEClass, ExpressionArgument.class, "ExpressionArgument", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1858 | initEReference(getBooleanObject_Value(), this.getBooleanValue(), null, "value", null, 0, 1, BooleanObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2226 | initEReference(getExpressionArgument_Body(), this.getExpression(), null, "body", null, 0, 1, ExpressionArgument.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1859 | 2227 | ||
| 1860 | initEClass(intObjectEClass, IntObject.class, "IntObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2228 | initEClass(starArgumentEClass, StarArgument.class, "StarArgument", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1861 | initEAttribute(getIntObject_Value(), ecorePackage.getEInt(), "value", null, 0, 1, IntObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1862 | 2229 | ||
| 1863 | initEClass(realObjectEClass, RealObject.class, "RealObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2230 | initEClass(typedArgumentEClass, TypedArgument.class, "TypedArgument", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1864 | initEAttribute(getRealObject_Value(), ecorePackage.getEBigDecimal(), "value", null, 0, 1, RealObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2231 | initEReference(getTypedArgument_Type(), this.getNamedElement(), null, "type", null, 0, 1, TypedArgument.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 2232 | initEReference(getTypedArgument_Variable(), this.getNamedElement(), null, "variable", null, 0, 1, TypedArgument.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1865 | 2233 | ||
| 1866 | initEClass(stringObjectEClass, StringObject.class, "StringObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2234 | initEClass(typedStarArgumentEClass, TypedStarArgument.class, "TypedStarArgument", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1867 | initEAttribute(getStringObject_Value(), ecorePackage.getEString(), "value", null, 0, 1, StringObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2235 | initEReference(getTypedStarArgument_Type(), this.getNamedElement(), null, "type", null, 0, 1, TypedStarArgument.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1868 | 2236 | ||
| 1869 | initEClass(predicateEClass, Predicate.class, "Predicate", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2237 | initEClass(referenceEClass, Reference.class, "Reference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1870 | initEAttribute(getPredicate_IsError(), ecorePackage.getEBoolean(), "isError", null, 0, 1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2238 | initEReference(getReference_Referred(), this.getNamedElement(), null, "referred", null, 0, 1, Reference.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1871 | initEReference(getPredicate_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1872 | initEReference(getPredicate_Parameters(), this.getParameter(), null, "parameters", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1873 | initEReference(getPredicate_Bodies(), this.getPatternBody(), null, "bodies", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1874 | 2239 | ||
| 1875 | initEClass(parameterEClass, Parameter.class, "Parameter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2240 | initEClass(intervalEClass, Interval.class, "Interval", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1876 | initEReference(getParameter_Variable(), this.getVariable(), null, "variable", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2241 | initEReference(getInterval_LowerBound(), this.getExpression(), null, "lowerBound", null, 0, 1, Interval.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1877 | initEReference(getParameter_Type(), this.getSymbol(), null, "type", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2242 | initEReference(getInterval_UpperBound(), this.getExpression(), null, "upperBound", null, 0, 1, Interval.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1878 | |||
| 1879 | initEClass(patternBodyEClass, PatternBody.class, "PatternBody", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1880 | initEReference(getPatternBody_Constraints(), this.getConstraint(), null, "constraints", null, 0, -1, PatternBody.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1881 | |||
| 1882 | initEClass(polarityEClass, Polarity.class, "Polarity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1883 | |||
| 1884 | initEClass(constraintEClass, Constraint.class, "Constraint", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1885 | initEReference(getConstraint_Polarity(), this.getPolarity(), null, "polarity", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1886 | initEReference(getConstraint_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1887 | initEReference(getConstraint_Params(), this.getLiteral(), null, "params", null, 0, -1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1888 | initEReference(getConstraint_ClosureType(), this.getClosureType(), null, "closureType", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1889 | |||
| 1890 | initEClass(closureTypeEClass, ClosureType.class, "ClosureType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1891 | 2243 | ||
| 1892 | initEClass(literalEClass, Literal.class, "Literal", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2244 | initEClass(literalEClass, Literal.class, "Literal", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1893 | 2245 | ||
| 1894 | initEClass(variableEClass, Variable.class, "Variable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2246 | initEClass(logicLiteralEClass, LogicLiteral.class, "LogicLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1895 | initEAttribute(getVariable_Name(), ecorePackage.getEString(), "name", null, 0, 1, Variable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | 2247 | initEAttribute(getLogicLiteral_Value(), this.getLogicValue(), "value", null, 0, 1, LogicLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); |
| 1896 | |||
| 1897 | initEClass(allInstancesEClass, AllInstances.class, "AllInstances", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1898 | initEReference(getAllInstances_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, AllInstances.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1899 | |||
| 1900 | initEClass(allObjectsEClass, AllObjects.class, "AllObjects", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1901 | |||
| 1902 | initEClass(defaultInterpretationEClass, DefaultInterpretation.class, "DefaultInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1903 | initEReference(getDefaultInterpretation_Interpretation(), this.getBasicInterpretation(), null, "interpretation", null, 0, 1, DefaultInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1904 | |||
| 1905 | initEClass(cdInterpretationEClass, CDInterpretation.class, "CDInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1906 | |||
| 1907 | initEClass(classInterpretationEClass, ClassInterpretation.class, "ClassInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1908 | initEAttribute(getClassInterpretation_Abstract(), ecorePackage.getEBoolean(), "abstract", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1909 | initEReference(getClassInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1910 | initEReference(getClassInterpretation_Supertypes(), this.getModelSymbol(), null, "supertypes", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1911 | initEReference(getClassInterpretation_Fielt(), this.getFieldRelationInterpretation(), null, "fielt", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1912 | |||
| 1913 | initEClass(enumInterpretationEClass, EnumInterpretation.class, "EnumInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1914 | initEReference(getEnumInterpretation_Symbol(), this.getModelSymbol(), null, "Symbol", null, 0, 1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1915 | initEReference(getEnumInterpretation_Objects(), this.getNamedObject(), null, "objects", null, 0, -1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1916 | |||
| 1917 | initEClass(fieldRelationInterpretationEClass, FieldRelationInterpretation.class, "FieldRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1918 | initEAttribute(getFieldRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1919 | initEReference(getFieldRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1920 | initEReference(getFieldRelationInterpretation_Multiplicity(), this.getMultiplicityDefinition(), null, "multiplicity", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1921 | initEReference(getFieldRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1922 | |||
| 1923 | initEClass(globalRelationInterpretationEClass, GlobalRelationInterpretation.class, "GlobalRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1924 | initEAttribute(getGlobalRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1925 | initEReference(getGlobalRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1926 | initEReference(getGlobalRelationInterpretation_SourceMultiplicity(), this.getMultiplicityDefinition(), null, "sourceMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1927 | initEReference(getGlobalRelationInterpretation_Source(), this.getSymbol(), null, "source", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1928 | initEReference(getGlobalRelationInterpretation_TargetMultiplicity(), this.getMultiplicityDefinition(), null, "targetMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1929 | initEReference(getGlobalRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1930 | |||
| 1931 | initEClass(multiplicityDefinitionEClass, MultiplicityDefinition.class, "MultiplicityDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1932 | initEAttribute(getMultiplicityDefinition_Lower(), ecorePackage.getEInt(), "lower", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1933 | initEAttribute(getMultiplicityDefinition_Upper(), ecorePackage.getEInt(), "upper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1934 | initEAttribute(getMultiplicityDefinition_UnlimitedUpper(), ecorePackage.getEBoolean(), "unlimitedUpper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1935 | |||
| 1936 | initEClass(booleanTrueEClass, BooleanTrue.class, "BooleanTrue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1937 | |||
| 1938 | initEClass(booleanFalseEClass, BooleanFalse.class, "BooleanFalse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1939 | |||
| 1940 | initEClass(trueEClass, True.class, "True", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1941 | |||
| 1942 | initEClass(falseEClass, False.class, "False", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1943 | |||
| 1944 | initEClass(unknownEClass, Unknown.class, "Unknown", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 1945 | 2248 | ||
| 1946 | initEClass(errorEClass, org.eclipse.viatra.solver.language.solverLanguage.Error.class, "Error", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2249 | initEClass(numericLiteralEClass, NumericLiteral.class, "NumericLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2250 | initEAttribute(getNumericLiteral_Value(), ecorePackage.getEBigDecimal(), "value", null, 0, 1, NumericLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1947 | 2251 | ||
| 1948 | initEClass(positiveEClass, Positive.class, "Positive", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2252 | initEClass(infinityLiteralEClass, InfinityLiteral.class, "InfinityLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1949 | 2253 | ||
| 1950 | initEClass(negativeEClass, Negative.class, "Negative", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2254 | initEClass(emptyIntervalLiteralEClass, EmptyIntervalLiteral.class, "EmptyIntervalLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 1951 | 2255 | ||
| 1952 | initEClass(reflexiveClosureEClass, ReflexiveClosure.class, "ReflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2256 | initEClass(stringLiteralEClass, StringLiteral.class, "StringLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2257 | initEAttribute(getStringLiteral_Value(), ecorePackage.getEString(), "value", null, 0, 1, StringLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 1953 | 2258 | ||
| 1954 | initEClass(irreflexiveClosureEClass, IrreflexiveClosure.class, "IrreflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | 2259 | initEClass(classDefinitionEClass, ClassDefinition.class, "ClassDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); |
| 2260 | initEAttribute(getClassDefinition_Abstract(), ecorePackage.getEBoolean(), "abstract", null, 0, 1, ClassDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2261 | initEAttribute(getClassDefinition_Name(), ecorePackage.getEString(), "name", null, 0, 1, ClassDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2262 | initEReference(getClassDefinition_Superclasses(), this.getNamedElement(), null, "superclasses", null, 0, -1, ClassDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2263 | initEReference(getClassDefinition_Members(), this.getMemberDefinition(), null, "members", null, 0, -1, ClassDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2264 | |||
| 2265 | initEClass(memberDefinitionEClass, MemberDefinition.class, "MemberDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2266 | initEAttribute(getMemberDefinition_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, MemberDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2267 | initEReference(getMemberDefinition_Type(), this.getNamedElement(), null, "type", null, 0, 1, MemberDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2268 | initEReference(getMemberDefinition_Multiplicity(), this.getMultiplicity(), null, "multiplicity", null, 0, 1, MemberDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2269 | initEAttribute(getMemberDefinition_Name(), ecorePackage.getEString(), "name", null, 0, 1, MemberDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2270 | initEReference(getMemberDefinition_Opposite(), this.getNamedElement(), null, "opposite", null, 0, 1, MemberDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2271 | |||
| 2272 | initEClass(multiplicityEClass, Multiplicity.class, "Multiplicity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2273 | |||
| 2274 | initEClass(manyMultiplicityEClass, ManyMultiplicity.class, "ManyMultiplicity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2275 | |||
| 2276 | initEClass(exactMultiplicityEClass, ExactMultiplicity.class, "ExactMultiplicity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2277 | initEAttribute(getExactMultiplicity_Multiplicity(), ecorePackage.getEInt(), "multiplicity", null, 0, 1, ExactMultiplicity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2278 | |||
| 2279 | initEClass(boundedMultiplicityEClass, BoundedMultiplicity.class, "BoundedMultiplicity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2280 | initEAttribute(getBoundedMultiplicity_LowerBound(), ecorePackage.getEInt(), "lowerBound", null, 0, 1, BoundedMultiplicity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2281 | initEAttribute(getBoundedMultiplicity_UpperBound(), ecorePackage.getEInt(), "upperBound", null, 0, 1, BoundedMultiplicity.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2282 | |||
| 2283 | initEClass(scopeDefinitionEClass, ScopeDefinition.class, "ScopeDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2284 | initEReference(getScopeDefinition_Type(), this.getNamedElement(), null, "type", null, 0, 1, ScopeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2285 | |||
| 2286 | initEClass(exactScopeDefinitionEClass, ExactScopeDefinition.class, "ExactScopeDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2287 | initEAttribute(getExactScopeDefinition_ExactScope(), ecorePackage.getEInt(), "exactScope", null, 0, 1, ExactScopeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2288 | |||
| 2289 | initEClass(boundedScopeDefinitionEClass, BoundedScopeDefinition.class, "BoundedScopeDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2290 | initEAttribute(getBoundedScopeDefinition_LowerBound(), ecorePackage.getEInt(), "lowerBound", null, 0, 1, BoundedScopeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2291 | initEAttribute(getBoundedScopeDefinition_UpperBound(), ecorePackage.getEInt(), "upperBound", null, 0, 1, BoundedScopeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2292 | |||
| 2293 | initEClass(lowerBoundedScopeDefinitionEClass, LowerBoundedScopeDefinition.class, "LowerBoundedScopeDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2294 | initEAttribute(getLowerBoundedScopeDefinition_LowerBound(), ecorePackage.getEInt(), "lowerBound", null, 0, 1, LowerBoundedScopeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2295 | |||
| 2296 | initEClass(objectiveDefinitionEClass, ObjectiveDefinition.class, "ObjectiveDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2297 | initEAttribute(getObjectiveDefinition_Kind(), this.getObjectiveKind(), "kind", null, 0, 1, ObjectiveDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2298 | initEReference(getObjectiveDefinition_Objective(), this.getExpression(), null, "objective", null, 0, 1, ObjectiveDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2299 | |||
| 2300 | initEClass(namedElementEClass, NamedElement.class, "NamedElement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2301 | initEAttribute(getNamedElement_Name(), ecorePackage.getEString(), "name", null, 0, 1, NamedElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2302 | |||
| 2303 | initEClass(assertionEClass, Assertion.class, "Assertion", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2304 | initEReference(getAssertion_Body(), this.getExpression(), null, "body", null, 0, 1, Assertion.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2305 | initEReference(getAssertion_Range(), this.getExpression(), null, "range", null, 0, 1, Assertion.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2306 | |||
| 2307 | initEClass(disjunctionEClass, Disjunction.class, "Disjunction", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2308 | initEReference(getDisjunction_Children(), this.getExpression(), null, "children", null, 0, -1, Disjunction.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2309 | |||
| 2310 | initEClass(switchEClass, Switch.class, "Switch", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2311 | initEReference(getSwitch_Cases(), this.getCase(), null, "cases", null, 0, -1, Switch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2312 | |||
| 2313 | initEClass(conjunctionEClass, Conjunction.class, "Conjunction", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2314 | initEReference(getConjunction_Children(), this.getExpression(), null, "children", null, 0, -1, Conjunction.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2315 | |||
| 2316 | initEClass(comparisonEClass, Comparison.class, "Comparison", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2317 | initEReference(getComparison_Left(), this.getExpression(), null, "left", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2318 | initEAttribute(getComparison_Op(), this.getBinaryOperator(), "op", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2319 | initEReference(getComparison_Right(), this.getExpression(), null, "right", null, 0, 1, Comparison.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2320 | |||
| 2321 | initEClass(binaryExpressionEClass, BinaryExpression.class, "BinaryExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2322 | initEReference(getBinaryExpression_Left(), this.getExpression(), null, "left", null, 0, 1, BinaryExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2323 | initEAttribute(getBinaryExpression_Op(), this.getBinaryOperator(), "op", null, 0, 1, BinaryExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2324 | initEReference(getBinaryExpression_Right(), this.getExpression(), null, "right", null, 0, 1, BinaryExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2325 | |||
| 2326 | initEClass(unaryExpressionEClass, UnaryExpression.class, "UnaryExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); | ||
| 2327 | initEAttribute(getUnaryExpression_Op(), this.getUnaryOp(), "op", null, 0, 1, UnaryExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2328 | initEReference(getUnaryExpression_Body(), this.getExpression(), null, "body", null, 0, 1, UnaryExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); | ||
| 2329 | |||
| 2330 | // Initialize enums and add enum literals | ||
| 2331 | initEEnum(metricTypeEEnum, MetricType.class, "MetricType"); | ||
| 2332 | addEEnumLiteral(metricTypeEEnum, MetricType.INT); | ||
| 2333 | addEEnumLiteral(metricTypeEEnum, MetricType.REAL); | ||
| 2334 | |||
| 2335 | initEEnum(binaryOperatorEEnum, BinaryOperator.class, "BinaryOperator"); | ||
| 2336 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.EQ); | ||
| 2337 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.NOT_EQ); | ||
| 2338 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.LESS); | ||
| 2339 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.LESS_EQ); | ||
| 2340 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.GREATER); | ||
| 2341 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.GREATER_EQ); | ||
| 2342 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.IN); | ||
| 2343 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.ADD); | ||
| 2344 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.SUB); | ||
| 2345 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.MUL); | ||
| 2346 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.DIV); | ||
| 2347 | addEEnumLiteral(binaryOperatorEEnum, BinaryOperator.POW); | ||
| 2348 | |||
| 2349 | initEEnum(unaryOpEEnum, UnaryOp.class, "UnaryOp"); | ||
| 2350 | addEEnumLiteral(unaryOpEEnum, UnaryOp.NEG); | ||
| 2351 | addEEnumLiteral(unaryOpEEnum, UnaryOp.PLUS); | ||
| 2352 | addEEnumLiteral(unaryOpEEnum, UnaryOp.MINUS); | ||
| 2353 | addEEnumLiteral(unaryOpEEnum, UnaryOp.MAY); | ||
| 2354 | addEEnumLiteral(unaryOpEEnum, UnaryOp.MUST); | ||
| 2355 | addEEnumLiteral(unaryOpEEnum, UnaryOp.CURRENT); | ||
| 2356 | |||
| 2357 | initEEnum(aggregationOpEEnum, AggregationOp.class, "AggregationOp"); | ||
| 2358 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.ONLY); | ||
| 2359 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.SUM); | ||
| 2360 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.PROD); | ||
| 2361 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.AVG); | ||
| 2362 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.MIN); | ||
| 2363 | addEEnumLiteral(aggregationOpEEnum, AggregationOp.MAX); | ||
| 2364 | |||
| 2365 | initEEnum(logicValueEEnum, LogicValue.class, "LogicValue"); | ||
| 2366 | addEEnumLiteral(logicValueEEnum, LogicValue.TRUE); | ||
| 2367 | addEEnumLiteral(logicValueEEnum, LogicValue.FALSE); | ||
| 2368 | addEEnumLiteral(logicValueEEnum, LogicValue.UNKNOWN); | ||
| 2369 | addEEnumLiteral(logicValueEEnum, LogicValue.ERROR); | ||
| 2370 | |||
| 2371 | initEEnum(objectiveKindEEnum, ObjectiveKind.class, "ObjectiveKind"); | ||
| 2372 | addEEnumLiteral(objectiveKindEEnum, ObjectiveKind.MINIMIZE); | ||
| 2373 | addEEnumLiteral(objectiveKindEEnum, ObjectiveKind.MAXIMIZE); | ||
| 1955 | 2374 | ||
| 1956 | // Create resource | 2375 | // Create resource |
| 1957 | createResource(eNS_URI); | 2376 | createResource(eNS_URI); |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StarArgumentImpl.java index faf3f06a..b0cecaab 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StarArgumentImpl.java | |||
| @@ -1,28 +1,28 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| 6 | import org.eclipse.emf.ecore.EClass; | 6 | import org.eclipse.emf.ecore.EClass; |
| 7 | 7 | ||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | 9 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; |
| 10 | 10 | ||
| 11 | /** | 11 | /** |
| 12 | * <!-- begin-user-doc --> | 12 | * <!-- begin-user-doc --> |
| 13 | * An implementation of the model object '<em><b>String Symbol</b></em>'. | 13 | * An implementation of the model object '<em><b>Star Argument</b></em>'. |
| 14 | * <!-- end-user-doc --> | 14 | * <!-- end-user-doc --> |
| 15 | * | 15 | * |
| 16 | * @generated | 16 | * @generated |
| 17 | */ | 17 | */ |
| 18 | public class StringSymbolImpl extends DataSymbolImpl implements StringSymbol | 18 | public class StarArgumentImpl extends ArgumentImpl implements StarArgument |
| 19 | { | 19 | { |
| 20 | /** | 20 | /** |
| 21 | * <!-- begin-user-doc --> | 21 | * <!-- begin-user-doc --> |
| 22 | * <!-- end-user-doc --> | 22 | * <!-- end-user-doc --> |
| 23 | * @generated | 23 | * @generated |
| 24 | */ | 24 | */ |
| 25 | protected StringSymbolImpl() | 25 | protected StarArgumentImpl() |
| 26 | { | 26 | { |
| 27 | super(); | 27 | super(); |
| 28 | } | 28 | } |
| @@ -35,7 +35,7 @@ public class StringSymbolImpl extends DataSymbolImpl implements StringSymbol | |||
| 35 | @Override | 35 | @Override |
| 36 | protected EClass eStaticClass() | 36 | protected EClass eStaticClass() |
| 37 | { | 37 | { |
| 38 | return SolverLanguagePackage.Literals.STRING_SYMBOL; | 38 | return SolverLanguagePackage.Literals.STAR_ARGUMENT; |
| 39 | } | 39 | } |
| 40 | 40 | ||
| 41 | } //StringSymbolImpl | 41 | } //StarArgumentImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java index 6e660396..d349d1a4 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringLiteralImpl.java index 7a7866a7..2b0b2720 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringLiteralImpl.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; |
| 5 | 5 | ||
| @@ -10,22 +10,22 @@ import org.eclipse.emf.ecore.EClass; | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| 11 | 11 | ||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | 12 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; |
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; |
| 14 | 14 | ||
| 15 | /** | 15 | /** |
| 16 | * <!-- begin-user-doc --> | 16 | * <!-- begin-user-doc --> |
| 17 | * An implementation of the model object '<em><b>String Object</b></em>'. | 17 | * An implementation of the model object '<em><b>String Literal</b></em>'. |
| 18 | * <!-- end-user-doc --> | 18 | * <!-- end-user-doc --> |
| 19 | * <p> | 19 | * <p> |
| 20 | * The following features are implemented: | 20 | * The following features are implemented: |
| 21 | * </p> | 21 | * </p> |
| 22 | * <ul> | 22 | * <ul> |
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl#getValue <em>Value</em>}</li> | 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringLiteralImpl#getValue <em>Value</em>}</li> |
| 24 | * </ul> | 24 | * </ul> |
| 25 | * | 25 | * |
| 26 | * @generated | 26 | * @generated |
| 27 | */ | 27 | */ |
| 28 | public class StringObjectImpl extends DataObjectImpl implements StringObject | 28 | public class StringLiteralImpl extends LiteralImpl implements StringLiteral |
| 29 | { | 29 | { |
| 30 | /** | 30 | /** |
| 31 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. | 31 | * The default value of the '{@link #getValue() <em>Value</em>}' attribute. |
| @@ -52,7 +52,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 52 | * <!-- end-user-doc --> | 52 | * <!-- end-user-doc --> |
| 53 | * @generated | 53 | * @generated |
| 54 | */ | 54 | */ |
| 55 | protected StringObjectImpl() | 55 | protected StringLiteralImpl() |
| 56 | { | 56 | { |
| 57 | super(); | 57 | super(); |
| 58 | } | 58 | } |
| @@ -65,7 +65,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 65 | @Override | 65 | @Override |
| 66 | protected EClass eStaticClass() | 66 | protected EClass eStaticClass() |
| 67 | { | 67 | { |
| 68 | return SolverLanguagePackage.Literals.STRING_OBJECT; | 68 | return SolverLanguagePackage.Literals.STRING_LITERAL; |
| 69 | } | 69 | } |
| 70 | 70 | ||
| 71 | /** | 71 | /** |
| @@ -90,7 +90,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 90 | String oldValue = value; | 90 | String oldValue = value; |
| 91 | value = newValue; | 91 | value = newValue; |
| 92 | if (eNotificationRequired()) | 92 | if (eNotificationRequired()) |
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.STRING_OBJECT__VALUE, oldValue, value)); | 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.STRING_LITERAL__VALUE, oldValue, value)); |
| 94 | } | 94 | } |
| 95 | 95 | ||
| 96 | /** | 96 | /** |
| @@ -103,7 +103,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 103 | { | 103 | { |
| 104 | switch (featureID) | 104 | switch (featureID) |
| 105 | { | 105 | { |
| 106 | case SolverLanguagePackage.STRING_OBJECT__VALUE: | 106 | case SolverLanguagePackage.STRING_LITERAL__VALUE: |
| 107 | return getValue(); | 107 | return getValue(); |
| 108 | } | 108 | } |
| 109 | return super.eGet(featureID, resolve, coreType); | 109 | return super.eGet(featureID, resolve, coreType); |
| @@ -119,7 +119,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 119 | { | 119 | { |
| 120 | switch (featureID) | 120 | switch (featureID) |
| 121 | { | 121 | { |
| 122 | case SolverLanguagePackage.STRING_OBJECT__VALUE: | 122 | case SolverLanguagePackage.STRING_LITERAL__VALUE: |
| 123 | setValue((String)newValue); | 123 | setValue((String)newValue); |
| 124 | return; | 124 | return; |
| 125 | } | 125 | } |
| @@ -136,7 +136,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 136 | { | 136 | { |
| 137 | switch (featureID) | 137 | switch (featureID) |
| 138 | { | 138 | { |
| 139 | case SolverLanguagePackage.STRING_OBJECT__VALUE: | 139 | case SolverLanguagePackage.STRING_LITERAL__VALUE: |
| 140 | setValue(VALUE_EDEFAULT); | 140 | setValue(VALUE_EDEFAULT); |
| 141 | return; | 141 | return; |
| 142 | } | 142 | } |
| @@ -153,7 +153,7 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 153 | { | 153 | { |
| 154 | switch (featureID) | 154 | switch (featureID) |
| 155 | { | 155 | { |
| 156 | case SolverLanguagePackage.STRING_OBJECT__VALUE: | 156 | case SolverLanguagePackage.STRING_LITERAL__VALUE: |
| 157 | return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); | 157 | return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); |
| 158 | } | 158 | } |
| 159 | return super.eIsSet(featureID); | 159 | return super.eIsSet(featureID); |
| @@ -176,4 +176,4 @@ public class StringObjectImpl extends DataObjectImpl implements StringObject | |||
| 176 | return result.toString(); | 176 | return result.toString(); |
| 177 | } | 177 | } |
| 178 | 178 | ||
| 179 | } //StringObjectImpl | 179 | } //StringLiteralImpl |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SwitchImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SwitchImpl.java new file mode 100644 index 00000000..fefd5be6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SwitchImpl.java | |||
| @@ -0,0 +1,167 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import java.util.Collection; | ||
| 7 | |||
| 8 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 9 | |||
| 10 | import org.eclipse.emf.common.util.EList; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.EClass; | ||
| 13 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 14 | |||
| 15 | import org.eclipse.emf.ecore.util.EObjectContainmentEList; | ||
| 16 | import org.eclipse.emf.ecore.util.InternalEList; | ||
| 17 | |||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.Case; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; | ||
| 21 | |||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * An implementation of the model object '<em><b>Switch</b></em>'. | ||
| 25 | * <!-- end-user-doc --> | ||
| 26 | * <p> | ||
| 27 | * The following features are implemented: | ||
| 28 | * </p> | ||
| 29 | * <ul> | ||
| 30 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SwitchImpl#getCases <em>Cases</em>}</li> | ||
| 31 | * </ul> | ||
| 32 | * | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | public class SwitchImpl extends ExpressionImpl implements Switch | ||
| 36 | { | ||
| 37 | /** | ||
| 38 | * The cached value of the '{@link #getCases() <em>Cases</em>}' containment reference list. | ||
| 39 | * <!-- begin-user-doc --> | ||
| 40 | * <!-- end-user-doc --> | ||
| 41 | * @see #getCases() | ||
| 42 | * @generated | ||
| 43 | * @ordered | ||
| 44 | */ | ||
| 45 | protected EList<Case> cases; | ||
| 46 | |||
| 47 | /** | ||
| 48 | * <!-- begin-user-doc --> | ||
| 49 | * <!-- end-user-doc --> | ||
| 50 | * @generated | ||
| 51 | */ | ||
| 52 | protected SwitchImpl() | ||
| 53 | { | ||
| 54 | super(); | ||
| 55 | } | ||
| 56 | |||
| 57 | /** | ||
| 58 | * <!-- begin-user-doc --> | ||
| 59 | * <!-- end-user-doc --> | ||
| 60 | * @generated | ||
| 61 | */ | ||
| 62 | @Override | ||
| 63 | protected EClass eStaticClass() | ||
| 64 | { | ||
| 65 | return SolverLanguagePackage.Literals.SWITCH; | ||
| 66 | } | ||
| 67 | |||
| 68 | /** | ||
| 69 | * <!-- begin-user-doc --> | ||
| 70 | * <!-- end-user-doc --> | ||
| 71 | * @generated | ||
| 72 | */ | ||
| 73 | @Override | ||
| 74 | public EList<Case> getCases() | ||
| 75 | { | ||
| 76 | if (cases == null) | ||
| 77 | { | ||
| 78 | cases = new EObjectContainmentEList<Case>(Case.class, this, SolverLanguagePackage.SWITCH__CASES); | ||
| 79 | } | ||
| 80 | return cases; | ||
| 81 | } | ||
| 82 | |||
| 83 | /** | ||
| 84 | * <!-- begin-user-doc --> | ||
| 85 | * <!-- end-user-doc --> | ||
| 86 | * @generated | ||
| 87 | */ | ||
| 88 | @Override | ||
| 89 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 90 | { | ||
| 91 | switch (featureID) | ||
| 92 | { | ||
| 93 | case SolverLanguagePackage.SWITCH__CASES: | ||
| 94 | return ((InternalEList<?>)getCases()).basicRemove(otherEnd, msgs); | ||
| 95 | } | ||
| 96 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 97 | } | ||
| 98 | |||
| 99 | /** | ||
| 100 | * <!-- begin-user-doc --> | ||
| 101 | * <!-- end-user-doc --> | ||
| 102 | * @generated | ||
| 103 | */ | ||
| 104 | @Override | ||
| 105 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 106 | { | ||
| 107 | switch (featureID) | ||
| 108 | { | ||
| 109 | case SolverLanguagePackage.SWITCH__CASES: | ||
| 110 | return getCases(); | ||
| 111 | } | ||
| 112 | return super.eGet(featureID, resolve, coreType); | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * <!-- begin-user-doc --> | ||
| 117 | * <!-- end-user-doc --> | ||
| 118 | * @generated | ||
| 119 | */ | ||
| 120 | @SuppressWarnings("unchecked") | ||
| 121 | @Override | ||
| 122 | public void eSet(int featureID, Object newValue) | ||
| 123 | { | ||
| 124 | switch (featureID) | ||
| 125 | { | ||
| 126 | case SolverLanguagePackage.SWITCH__CASES: | ||
| 127 | getCases().clear(); | ||
| 128 | getCases().addAll((Collection<? extends Case>)newValue); | ||
| 129 | return; | ||
| 130 | } | ||
| 131 | super.eSet(featureID, newValue); | ||
| 132 | } | ||
| 133 | |||
| 134 | /** | ||
| 135 | * <!-- begin-user-doc --> | ||
| 136 | * <!-- end-user-doc --> | ||
| 137 | * @generated | ||
| 138 | */ | ||
| 139 | @Override | ||
| 140 | public void eUnset(int featureID) | ||
| 141 | { | ||
| 142 | switch (featureID) | ||
| 143 | { | ||
| 144 | case SolverLanguagePackage.SWITCH__CASES: | ||
| 145 | getCases().clear(); | ||
| 146 | return; | ||
| 147 | } | ||
| 148 | super.eUnset(featureID); | ||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * <!-- begin-user-doc --> | ||
| 153 | * <!-- end-user-doc --> | ||
| 154 | * @generated | ||
| 155 | */ | ||
| 156 | @Override | ||
| 157 | public boolean eIsSet(int featureID) | ||
| 158 | { | ||
| 159 | switch (featureID) | ||
| 160 | { | ||
| 161 | case SolverLanguagePackage.SWITCH__CASES: | ||
| 162 | return cases != null && !cases.isEmpty(); | ||
| 163 | } | ||
| 164 | return super.eIsSet(featureID); | ||
| 165 | } | ||
| 166 | |||
| 167 | } //SwitchImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java deleted file mode 100644 index 15d1294e..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java +++ /dev/null | |||
| @@ -1,43 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 9 | |||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * <!-- begin-user-doc --> | ||
| 15 | * An implementation of the model object '<em><b>Symbol</b></em>'. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * | ||
| 18 | * @generated | ||
| 19 | */ | ||
| 20 | public class SymbolImpl extends MinimalEObjectImpl.Container implements Symbol | ||
| 21 | { | ||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * <!-- end-user-doc --> | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | protected SymbolImpl() | ||
| 28 | { | ||
| 29 | super(); | ||
| 30 | } | ||
| 31 | |||
| 32 | /** | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | @Override | ||
| 38 | protected EClass eStaticClass() | ||
| 39 | { | ||
| 40 | return SolverLanguagePackage.Literals.SYMBOL; | ||
| 41 | } | ||
| 42 | |||
| 43 | } //SymbolImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java deleted file mode 100644 index c0e04a9a..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java +++ /dev/null | |||
| @@ -1,41 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 9 | import org.eclipse.viatra.solver.language.solverLanguage.True; | ||
| 10 | |||
| 11 | /** | ||
| 12 | * <!-- begin-user-doc --> | ||
| 13 | * An implementation of the model object '<em><b>True</b></em>'. | ||
| 14 | * <!-- end-user-doc --> | ||
| 15 | * | ||
| 16 | * @generated | ||
| 17 | */ | ||
| 18 | public class TrueImpl extends TruthValueImpl implements True | ||
| 19 | { | ||
| 20 | /** | ||
| 21 | * <!-- begin-user-doc --> | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * @generated | ||
| 24 | */ | ||
| 25 | protected TrueImpl() | ||
| 26 | { | ||
| 27 | super(); | ||
| 28 | } | ||
| 29 | |||
| 30 | /** | ||
| 31 | * <!-- begin-user-doc --> | ||
| 32 | * <!-- end-user-doc --> | ||
| 33 | * @generated | ||
| 34 | */ | ||
| 35 | @Override | ||
| 36 | protected EClass eStaticClass() | ||
| 37 | { | ||
| 38 | return SolverLanguagePackage.Literals.TRUE; | ||
| 39 | } | ||
| 40 | |||
| 41 | } //TrueImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java deleted file mode 100644 index f5b0fba6..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java +++ /dev/null | |||
| @@ -1,43 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.ecore.EClass; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; | ||
| 9 | |||
| 10 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * <!-- begin-user-doc --> | ||
| 15 | * An implementation of the model object '<em><b>Truth Value</b></em>'. | ||
| 16 | * <!-- end-user-doc --> | ||
| 17 | * | ||
| 18 | * @generated | ||
| 19 | */ | ||
| 20 | public class TruthValueImpl extends MinimalEObjectImpl.Container implements TruthValue | ||
| 21 | { | ||
| 22 | /** | ||
| 23 | * <!-- begin-user-doc --> | ||
| 24 | * <!-- end-user-doc --> | ||
| 25 | * @generated | ||
| 26 | */ | ||
| 27 | protected TruthValueImpl() | ||
| 28 | { | ||
| 29 | super(); | ||
| 30 | } | ||
| 31 | |||
| 32 | /** | ||
| 33 | * <!-- begin-user-doc --> | ||
| 34 | * <!-- end-user-doc --> | ||
| 35 | * @generated | ||
| 36 | */ | ||
| 37 | @Override | ||
| 38 | protected EClass eStaticClass() | ||
| 39 | { | ||
| 40 | return SolverLanguagePackage.Literals.TRUTH_VALUE; | ||
| 41 | } | ||
| 42 | |||
| 43 | } //TruthValueImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedArgumentImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedArgumentImpl.java new file mode 100644 index 00000000..2d93f402 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedArgumentImpl.java | |||
| @@ -0,0 +1,242 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 10 | |||
| 11 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 12 | |||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument; | ||
| 16 | |||
| 17 | /** | ||
| 18 | * <!-- begin-user-doc --> | ||
| 19 | * An implementation of the model object '<em><b>Typed Argument</b></em>'. | ||
| 20 | * <!-- end-user-doc --> | ||
| 21 | * <p> | ||
| 22 | * The following features are implemented: | ||
| 23 | * </p> | ||
| 24 | * <ul> | ||
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl#getType <em>Type</em>}</li> | ||
| 26 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedArgumentImpl#getVariable <em>Variable</em>}</li> | ||
| 27 | * </ul> | ||
| 28 | * | ||
| 29 | * @generated | ||
| 30 | */ | ||
| 31 | public class TypedArgumentImpl extends ArgumentImpl implements TypedArgument | ||
| 32 | { | ||
| 33 | /** | ||
| 34 | * The cached value of the '{@link #getType() <em>Type</em>}' reference. | ||
| 35 | * <!-- begin-user-doc --> | ||
| 36 | * <!-- end-user-doc --> | ||
| 37 | * @see #getType() | ||
| 38 | * @generated | ||
| 39 | * @ordered | ||
| 40 | */ | ||
| 41 | protected NamedElement type; | ||
| 42 | |||
| 43 | /** | ||
| 44 | * The cached value of the '{@link #getVariable() <em>Variable</em>}' reference. | ||
| 45 | * <!-- begin-user-doc --> | ||
| 46 | * <!-- end-user-doc --> | ||
| 47 | * @see #getVariable() | ||
| 48 | * @generated | ||
| 49 | * @ordered | ||
| 50 | */ | ||
| 51 | protected NamedElement variable; | ||
| 52 | |||
| 53 | /** | ||
| 54 | * <!-- begin-user-doc --> | ||
| 55 | * <!-- end-user-doc --> | ||
| 56 | * @generated | ||
| 57 | */ | ||
| 58 | protected TypedArgumentImpl() | ||
| 59 | { | ||
| 60 | super(); | ||
| 61 | } | ||
| 62 | |||
| 63 | /** | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | @Override | ||
| 69 | protected EClass eStaticClass() | ||
| 70 | { | ||
| 71 | return SolverLanguagePackage.Literals.TYPED_ARGUMENT; | ||
| 72 | } | ||
| 73 | |||
| 74 | /** | ||
| 75 | * <!-- begin-user-doc --> | ||
| 76 | * <!-- end-user-doc --> | ||
| 77 | * @generated | ||
| 78 | */ | ||
| 79 | @Override | ||
| 80 | public NamedElement getType() | ||
| 81 | { | ||
| 82 | if (type != null && type.eIsProxy()) | ||
| 83 | { | ||
| 84 | InternalEObject oldType = (InternalEObject)type; | ||
| 85 | type = (NamedElement)eResolveProxy(oldType); | ||
| 86 | if (type != oldType) | ||
| 87 | { | ||
| 88 | if (eNotificationRequired()) | ||
| 89 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.TYPED_ARGUMENT__TYPE, oldType, type)); | ||
| 90 | } | ||
| 91 | } | ||
| 92 | return type; | ||
| 93 | } | ||
| 94 | |||
| 95 | /** | ||
| 96 | * <!-- begin-user-doc --> | ||
| 97 | * <!-- end-user-doc --> | ||
| 98 | * @generated | ||
| 99 | */ | ||
| 100 | public NamedElement basicGetType() | ||
| 101 | { | ||
| 102 | return type; | ||
| 103 | } | ||
| 104 | |||
| 105 | /** | ||
| 106 | * <!-- begin-user-doc --> | ||
| 107 | * <!-- end-user-doc --> | ||
| 108 | * @generated | ||
| 109 | */ | ||
| 110 | @Override | ||
| 111 | public void setType(NamedElement newType) | ||
| 112 | { | ||
| 113 | NamedElement oldType = type; | ||
| 114 | type = newType; | ||
| 115 | if (eNotificationRequired()) | ||
| 116 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.TYPED_ARGUMENT__TYPE, oldType, type)); | ||
| 117 | } | ||
| 118 | |||
| 119 | /** | ||
| 120 | * <!-- begin-user-doc --> | ||
| 121 | * <!-- end-user-doc --> | ||
| 122 | * @generated | ||
| 123 | */ | ||
| 124 | @Override | ||
| 125 | public NamedElement getVariable() | ||
| 126 | { | ||
| 127 | if (variable != null && variable.eIsProxy()) | ||
| 128 | { | ||
| 129 | InternalEObject oldVariable = (InternalEObject)variable; | ||
| 130 | variable = (NamedElement)eResolveProxy(oldVariable); | ||
| 131 | if (variable != oldVariable) | ||
| 132 | { | ||
| 133 | if (eNotificationRequired()) | ||
| 134 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE, oldVariable, variable)); | ||
| 135 | } | ||
| 136 | } | ||
| 137 | return variable; | ||
| 138 | } | ||
| 139 | |||
| 140 | /** | ||
| 141 | * <!-- begin-user-doc --> | ||
| 142 | * <!-- end-user-doc --> | ||
| 143 | * @generated | ||
| 144 | */ | ||
| 145 | public NamedElement basicGetVariable() | ||
| 146 | { | ||
| 147 | return variable; | ||
| 148 | } | ||
| 149 | |||
| 150 | /** | ||
| 151 | * <!-- begin-user-doc --> | ||
| 152 | * <!-- end-user-doc --> | ||
| 153 | * @generated | ||
| 154 | */ | ||
| 155 | @Override | ||
| 156 | public void setVariable(NamedElement newVariable) | ||
| 157 | { | ||
| 158 | NamedElement oldVariable = variable; | ||
| 159 | variable = newVariable; | ||
| 160 | if (eNotificationRequired()) | ||
| 161 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE, oldVariable, variable)); | ||
| 162 | } | ||
| 163 | |||
| 164 | /** | ||
| 165 | * <!-- begin-user-doc --> | ||
| 166 | * <!-- end-user-doc --> | ||
| 167 | * @generated | ||
| 168 | */ | ||
| 169 | @Override | ||
| 170 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 171 | { | ||
| 172 | switch (featureID) | ||
| 173 | { | ||
| 174 | case SolverLanguagePackage.TYPED_ARGUMENT__TYPE: | ||
| 175 | if (resolve) return getType(); | ||
| 176 | return basicGetType(); | ||
| 177 | case SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE: | ||
| 178 | if (resolve) return getVariable(); | ||
| 179 | return basicGetVariable(); | ||
| 180 | } | ||
| 181 | return super.eGet(featureID, resolve, coreType); | ||
| 182 | } | ||
| 183 | |||
| 184 | /** | ||
| 185 | * <!-- begin-user-doc --> | ||
| 186 | * <!-- end-user-doc --> | ||
| 187 | * @generated | ||
| 188 | */ | ||
| 189 | @Override | ||
| 190 | public void eSet(int featureID, Object newValue) | ||
| 191 | { | ||
| 192 | switch (featureID) | ||
| 193 | { | ||
| 194 | case SolverLanguagePackage.TYPED_ARGUMENT__TYPE: | ||
| 195 | setType((NamedElement)newValue); | ||
| 196 | return; | ||
| 197 | case SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE: | ||
| 198 | setVariable((NamedElement)newValue); | ||
| 199 | return; | ||
| 200 | } | ||
| 201 | super.eSet(featureID, newValue); | ||
| 202 | } | ||
| 203 | |||
| 204 | /** | ||
| 205 | * <!-- begin-user-doc --> | ||
| 206 | * <!-- end-user-doc --> | ||
| 207 | * @generated | ||
| 208 | */ | ||
| 209 | @Override | ||
| 210 | public void eUnset(int featureID) | ||
| 211 | { | ||
| 212 | switch (featureID) | ||
| 213 | { | ||
| 214 | case SolverLanguagePackage.TYPED_ARGUMENT__TYPE: | ||
| 215 | setType((NamedElement)null); | ||
| 216 | return; | ||
| 217 | case SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE: | ||
| 218 | setVariable((NamedElement)null); | ||
| 219 | return; | ||
| 220 | } | ||
| 221 | super.eUnset(featureID); | ||
| 222 | } | ||
| 223 | |||
| 224 | /** | ||
| 225 | * <!-- begin-user-doc --> | ||
| 226 | * <!-- end-user-doc --> | ||
| 227 | * @generated | ||
| 228 | */ | ||
| 229 | @Override | ||
| 230 | public boolean eIsSet(int featureID) | ||
| 231 | { | ||
| 232 | switch (featureID) | ||
| 233 | { | ||
| 234 | case SolverLanguagePackage.TYPED_ARGUMENT__TYPE: | ||
| 235 | return type != null; | ||
| 236 | case SolverLanguagePackage.TYPED_ARGUMENT__VARIABLE: | ||
| 237 | return variable != null; | ||
| 238 | } | ||
| 239 | return super.eIsSet(featureID); | ||
| 240 | } | ||
| 241 | |||
| 242 | } //TypedArgumentImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedStarArgumentImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedStarArgumentImpl.java new file mode 100644 index 00000000..dd2b46bc --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TypedStarArgumentImpl.java | |||
| @@ -0,0 +1,175 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 10 | |||
| 11 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 12 | |||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.NamedElement; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; | ||
| 16 | |||
| 17 | /** | ||
| 18 | * <!-- begin-user-doc --> | ||
| 19 | * An implementation of the model object '<em><b>Typed Star Argument</b></em>'. | ||
| 20 | * <!-- end-user-doc --> | ||
| 21 | * <p> | ||
| 22 | * The following features are implemented: | ||
| 23 | * </p> | ||
| 24 | * <ul> | ||
| 25 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TypedStarArgumentImpl#getType <em>Type</em>}</li> | ||
| 26 | * </ul> | ||
| 27 | * | ||
| 28 | * @generated | ||
| 29 | */ | ||
| 30 | public class TypedStarArgumentImpl extends ArgumentImpl implements TypedStarArgument | ||
| 31 | { | ||
| 32 | /** | ||
| 33 | * The cached value of the '{@link #getType() <em>Type</em>}' reference. | ||
| 34 | * <!-- begin-user-doc --> | ||
| 35 | * <!-- end-user-doc --> | ||
| 36 | * @see #getType() | ||
| 37 | * @generated | ||
| 38 | * @ordered | ||
| 39 | */ | ||
| 40 | protected NamedElement type; | ||
| 41 | |||
| 42 | /** | ||
| 43 | * <!-- begin-user-doc --> | ||
| 44 | * <!-- end-user-doc --> | ||
| 45 | * @generated | ||
| 46 | */ | ||
| 47 | protected TypedStarArgumentImpl() | ||
| 48 | { | ||
| 49 | super(); | ||
| 50 | } | ||
| 51 | |||
| 52 | /** | ||
| 53 | * <!-- begin-user-doc --> | ||
| 54 | * <!-- end-user-doc --> | ||
| 55 | * @generated | ||
| 56 | */ | ||
| 57 | @Override | ||
| 58 | protected EClass eStaticClass() | ||
| 59 | { | ||
| 60 | return SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT; | ||
| 61 | } | ||
| 62 | |||
| 63 | /** | ||
| 64 | * <!-- begin-user-doc --> | ||
| 65 | * <!-- end-user-doc --> | ||
| 66 | * @generated | ||
| 67 | */ | ||
| 68 | @Override | ||
| 69 | public NamedElement getType() | ||
| 70 | { | ||
| 71 | if (type != null && type.eIsProxy()) | ||
| 72 | { | ||
| 73 | InternalEObject oldType = (InternalEObject)type; | ||
| 74 | type = (NamedElement)eResolveProxy(oldType); | ||
| 75 | if (type != oldType) | ||
| 76 | { | ||
| 77 | if (eNotificationRequired()) | ||
| 78 | eNotify(new ENotificationImpl(this, Notification.RESOLVE, SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE, oldType, type)); | ||
| 79 | } | ||
| 80 | } | ||
| 81 | return type; | ||
| 82 | } | ||
| 83 | |||
| 84 | /** | ||
| 85 | * <!-- begin-user-doc --> | ||
| 86 | * <!-- end-user-doc --> | ||
| 87 | * @generated | ||
| 88 | */ | ||
| 89 | public NamedElement basicGetType() | ||
| 90 | { | ||
| 91 | return type; | ||
| 92 | } | ||
| 93 | |||
| 94 | /** | ||
| 95 | * <!-- begin-user-doc --> | ||
| 96 | * <!-- end-user-doc --> | ||
| 97 | * @generated | ||
| 98 | */ | ||
| 99 | @Override | ||
| 100 | public void setType(NamedElement newType) | ||
| 101 | { | ||
| 102 | NamedElement oldType = type; | ||
| 103 | type = newType; | ||
| 104 | if (eNotificationRequired()) | ||
| 105 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE, oldType, type)); | ||
| 106 | } | ||
| 107 | |||
| 108 | /** | ||
| 109 | * <!-- begin-user-doc --> | ||
| 110 | * <!-- end-user-doc --> | ||
| 111 | * @generated | ||
| 112 | */ | ||
| 113 | @Override | ||
| 114 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 115 | { | ||
| 116 | switch (featureID) | ||
| 117 | { | ||
| 118 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE: | ||
| 119 | if (resolve) return getType(); | ||
| 120 | return basicGetType(); | ||
| 121 | } | ||
| 122 | return super.eGet(featureID, resolve, coreType); | ||
| 123 | } | ||
| 124 | |||
| 125 | /** | ||
| 126 | * <!-- begin-user-doc --> | ||
| 127 | * <!-- end-user-doc --> | ||
| 128 | * @generated | ||
| 129 | */ | ||
| 130 | @Override | ||
| 131 | public void eSet(int featureID, Object newValue) | ||
| 132 | { | ||
| 133 | switch (featureID) | ||
| 134 | { | ||
| 135 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE: | ||
| 136 | setType((NamedElement)newValue); | ||
| 137 | return; | ||
| 138 | } | ||
| 139 | super.eSet(featureID, newValue); | ||
| 140 | } | ||
| 141 | |||
| 142 | /** | ||
| 143 | * <!-- begin-user-doc --> | ||
| 144 | * <!-- end-user-doc --> | ||
| 145 | * @generated | ||
| 146 | */ | ||
| 147 | @Override | ||
| 148 | public void eUnset(int featureID) | ||
| 149 | { | ||
| 150 | switch (featureID) | ||
| 151 | { | ||
| 152 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE: | ||
| 153 | setType((NamedElement)null); | ||
| 154 | return; | ||
| 155 | } | ||
| 156 | super.eUnset(featureID); | ||
| 157 | } | ||
| 158 | |||
| 159 | /** | ||
| 160 | * <!-- begin-user-doc --> | ||
| 161 | * <!-- end-user-doc --> | ||
| 162 | * @generated | ||
| 163 | */ | ||
| 164 | @Override | ||
| 165 | public boolean eIsSet(int featureID) | ||
| 166 | { | ||
| 167 | switch (featureID) | ||
| 168 | { | ||
| 169 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT__TYPE: | ||
| 170 | return type != null; | ||
| 171 | } | ||
| 172 | return super.eIsSet(featureID); | ||
| 173 | } | ||
| 174 | |||
| 175 | } //TypedStarArgumentImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnaryExpressionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnaryExpressionImpl.java new file mode 100644 index 00000000..ee5ebfbb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnaryExpressionImpl.java | |||
| @@ -0,0 +1,270 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryOp; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Unary Expression</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl#getOp <em>Op</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnaryExpressionImpl#getBody <em>Body</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class UnaryExpressionImpl extends ExpressionImpl implements UnaryExpression | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The default value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getOp() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected static final UnaryOp OP_EDEFAULT = UnaryOp.NEG; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getOp() <em>Op</em>}' attribute. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getOp() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected UnaryOp op = OP_EDEFAULT; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 57 | * <!-- begin-user-doc --> | ||
| 58 | * <!-- end-user-doc --> | ||
| 59 | * @see #getBody() | ||
| 60 | * @generated | ||
| 61 | * @ordered | ||
| 62 | */ | ||
| 63 | protected Expression body; | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | protected UnaryExpressionImpl() | ||
| 71 | { | ||
| 72 | super(); | ||
| 73 | } | ||
| 74 | |||
| 75 | /** | ||
| 76 | * <!-- begin-user-doc --> | ||
| 77 | * <!-- end-user-doc --> | ||
| 78 | * @generated | ||
| 79 | */ | ||
| 80 | @Override | ||
| 81 | protected EClass eStaticClass() | ||
| 82 | { | ||
| 83 | return SolverLanguagePackage.Literals.UNARY_EXPRESSION; | ||
| 84 | } | ||
| 85 | |||
| 86 | /** | ||
| 87 | * <!-- begin-user-doc --> | ||
| 88 | * <!-- end-user-doc --> | ||
| 89 | * @generated | ||
| 90 | */ | ||
| 91 | @Override | ||
| 92 | public UnaryOp getOp() | ||
| 93 | { | ||
| 94 | return op; | ||
| 95 | } | ||
| 96 | |||
| 97 | /** | ||
| 98 | * <!-- begin-user-doc --> | ||
| 99 | * <!-- end-user-doc --> | ||
| 100 | * @generated | ||
| 101 | */ | ||
| 102 | @Override | ||
| 103 | public void setOp(UnaryOp newOp) | ||
| 104 | { | ||
| 105 | UnaryOp oldOp = op; | ||
| 106 | op = newOp == null ? OP_EDEFAULT : newOp; | ||
| 107 | if (eNotificationRequired()) | ||
| 108 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNARY_EXPRESSION__OP, oldOp, op)); | ||
| 109 | } | ||
| 110 | |||
| 111 | /** | ||
| 112 | * <!-- begin-user-doc --> | ||
| 113 | * <!-- end-user-doc --> | ||
| 114 | * @generated | ||
| 115 | */ | ||
| 116 | @Override | ||
| 117 | public Expression getBody() | ||
| 118 | { | ||
| 119 | return body; | ||
| 120 | } | ||
| 121 | |||
| 122 | /** | ||
| 123 | * <!-- begin-user-doc --> | ||
| 124 | * <!-- end-user-doc --> | ||
| 125 | * @generated | ||
| 126 | */ | ||
| 127 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 128 | { | ||
| 129 | Expression oldBody = body; | ||
| 130 | body = newBody; | ||
| 131 | if (eNotificationRequired()) | ||
| 132 | { | ||
| 133 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNARY_EXPRESSION__BODY, oldBody, newBody); | ||
| 134 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 135 | } | ||
| 136 | return msgs; | ||
| 137 | } | ||
| 138 | |||
| 139 | /** | ||
| 140 | * <!-- begin-user-doc --> | ||
| 141 | * <!-- end-user-doc --> | ||
| 142 | * @generated | ||
| 143 | */ | ||
| 144 | @Override | ||
| 145 | public void setBody(Expression newBody) | ||
| 146 | { | ||
| 147 | if (newBody != body) | ||
| 148 | { | ||
| 149 | NotificationChain msgs = null; | ||
| 150 | if (body != null) | ||
| 151 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNARY_EXPRESSION__BODY, null, msgs); | ||
| 152 | if (newBody != null) | ||
| 153 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNARY_EXPRESSION__BODY, null, msgs); | ||
| 154 | msgs = basicSetBody(newBody, msgs); | ||
| 155 | if (msgs != null) msgs.dispatch(); | ||
| 156 | } | ||
| 157 | else if (eNotificationRequired()) | ||
| 158 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNARY_EXPRESSION__BODY, newBody, newBody)); | ||
| 159 | } | ||
| 160 | |||
| 161 | /** | ||
| 162 | * <!-- begin-user-doc --> | ||
| 163 | * <!-- end-user-doc --> | ||
| 164 | * @generated | ||
| 165 | */ | ||
| 166 | @Override | ||
| 167 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 168 | { | ||
| 169 | switch (featureID) | ||
| 170 | { | ||
| 171 | case SolverLanguagePackage.UNARY_EXPRESSION__BODY: | ||
| 172 | return basicSetBody(null, msgs); | ||
| 173 | } | ||
| 174 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 175 | } | ||
| 176 | |||
| 177 | /** | ||
| 178 | * <!-- begin-user-doc --> | ||
| 179 | * <!-- end-user-doc --> | ||
| 180 | * @generated | ||
| 181 | */ | ||
| 182 | @Override | ||
| 183 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 184 | { | ||
| 185 | switch (featureID) | ||
| 186 | { | ||
| 187 | case SolverLanguagePackage.UNARY_EXPRESSION__OP: | ||
| 188 | return getOp(); | ||
| 189 | case SolverLanguagePackage.UNARY_EXPRESSION__BODY: | ||
| 190 | return getBody(); | ||
| 191 | } | ||
| 192 | return super.eGet(featureID, resolve, coreType); | ||
| 193 | } | ||
| 194 | |||
| 195 | /** | ||
| 196 | * <!-- begin-user-doc --> | ||
| 197 | * <!-- end-user-doc --> | ||
| 198 | * @generated | ||
| 199 | */ | ||
| 200 | @Override | ||
| 201 | public void eSet(int featureID, Object newValue) | ||
| 202 | { | ||
| 203 | switch (featureID) | ||
| 204 | { | ||
| 205 | case SolverLanguagePackage.UNARY_EXPRESSION__OP: | ||
| 206 | setOp((UnaryOp)newValue); | ||
| 207 | return; | ||
| 208 | case SolverLanguagePackage.UNARY_EXPRESSION__BODY: | ||
| 209 | setBody((Expression)newValue); | ||
| 210 | return; | ||
| 211 | } | ||
| 212 | super.eSet(featureID, newValue); | ||
| 213 | } | ||
| 214 | |||
| 215 | /** | ||
| 216 | * <!-- begin-user-doc --> | ||
| 217 | * <!-- end-user-doc --> | ||
| 218 | * @generated | ||
| 219 | */ | ||
| 220 | @Override | ||
| 221 | public void eUnset(int featureID) | ||
| 222 | { | ||
| 223 | switch (featureID) | ||
| 224 | { | ||
| 225 | case SolverLanguagePackage.UNARY_EXPRESSION__OP: | ||
| 226 | setOp(OP_EDEFAULT); | ||
| 227 | return; | ||
| 228 | case SolverLanguagePackage.UNARY_EXPRESSION__BODY: | ||
| 229 | setBody((Expression)null); | ||
| 230 | return; | ||
| 231 | } | ||
| 232 | super.eUnset(featureID); | ||
| 233 | } | ||
| 234 | |||
| 235 | /** | ||
| 236 | * <!-- begin-user-doc --> | ||
| 237 | * <!-- end-user-doc --> | ||
| 238 | * @generated | ||
| 239 | */ | ||
| 240 | @Override | ||
| 241 | public boolean eIsSet(int featureID) | ||
| 242 | { | ||
| 243 | switch (featureID) | ||
| 244 | { | ||
| 245 | case SolverLanguagePackage.UNARY_EXPRESSION__OP: | ||
| 246 | return op != OP_EDEFAULT; | ||
| 247 | case SolverLanguagePackage.UNARY_EXPRESSION__BODY: | ||
| 248 | return body != null; | ||
| 249 | } | ||
| 250 | return super.eIsSet(featureID); | ||
| 251 | } | ||
| 252 | |||
| 253 | /** | ||
| 254 | * <!-- begin-user-doc --> | ||
| 255 | * <!-- end-user-doc --> | ||
| 256 | * @generated | ||
| 257 | */ | ||
| 258 | @Override | ||
| 259 | public String toString() | ||
| 260 | { | ||
| 261 | if (eIsProxy()) return super.toString(); | ||
| 262 | |||
| 263 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 264 | result.append(" (op: "); | ||
| 265 | result.append(op); | ||
| 266 | result.append(')'); | ||
| 267 | return result.toString(); | ||
| 268 | } | ||
| 269 | |||
| 270 | } //UnaryExpressionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedErrorPrediateDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedErrorPrediateDefinitionImpl.java new file mode 100644 index 00000000..cd6a3271 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedErrorPrediateDefinitionImpl.java | |||
| @@ -0,0 +1,270 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.21.0 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | import org.eclipse.emf.common.notify.NotificationChain; | ||
| 8 | |||
| 9 | import org.eclipse.emf.ecore.EClass; | ||
| 10 | import org.eclipse.emf.ecore.InternalEObject; | ||
| 11 | |||
| 12 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 13 | |||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.Expression; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition; | ||
| 18 | |||
| 19 | /** | ||
| 20 | * <!-- begin-user-doc --> | ||
| 21 | * An implementation of the model object '<em><b>Unnamed Error Prediate Definition</b></em>'. | ||
| 22 | * <!-- end-user-doc --> | ||
| 23 | * <p> | ||
| 24 | * The following features are implemented: | ||
| 25 | * </p> | ||
| 26 | * <ul> | ||
| 27 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl#getArgumentList <em>Argument List</em>}</li> | ||
| 28 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedErrorPrediateDefinitionImpl#getBody <em>Body</em>}</li> | ||
| 29 | * </ul> | ||
| 30 | * | ||
| 31 | * @generated | ||
| 32 | */ | ||
| 33 | public class UnnamedErrorPrediateDefinitionImpl extends StatementImpl implements UnnamedErrorPrediateDefinition | ||
| 34 | { | ||
| 35 | /** | ||
| 36 | * The cached value of the '{@link #getArgumentList() <em>Argument List</em>}' containment reference. | ||
| 37 | * <!-- begin-user-doc --> | ||
| 38 | * <!-- end-user-doc --> | ||
| 39 | * @see #getArgumentList() | ||
| 40 | * @generated | ||
| 41 | * @ordered | ||
| 42 | */ | ||
| 43 | protected ArgumentList argumentList; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * The cached value of the '{@link #getBody() <em>Body</em>}' containment reference. | ||
| 47 | * <!-- begin-user-doc --> | ||
| 48 | * <!-- end-user-doc --> | ||
| 49 | * @see #getBody() | ||
| 50 | * @generated | ||
| 51 | * @ordered | ||
| 52 | */ | ||
| 53 | protected Expression body; | ||
| 54 | |||
| 55 | /** | ||
| 56 | * <!-- begin-user-doc --> | ||
| 57 | * <!-- end-user-doc --> | ||
| 58 | * @generated | ||
| 59 | */ | ||
| 60 | protected UnnamedErrorPrediateDefinitionImpl() | ||
| 61 | { | ||
| 62 | super(); | ||
| 63 | } | ||
| 64 | |||
| 65 | /** | ||
| 66 | * <!-- begin-user-doc --> | ||
| 67 | * <!-- end-user-doc --> | ||
| 68 | * @generated | ||
| 69 | */ | ||
| 70 | @Override | ||
| 71 | protected EClass eStaticClass() | ||
| 72 | { | ||
| 73 | return SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION; | ||
| 74 | } | ||
| 75 | |||
| 76 | /** | ||
| 77 | * <!-- begin-user-doc --> | ||
| 78 | * <!-- end-user-doc --> | ||
| 79 | * @generated | ||
| 80 | */ | ||
| 81 | @Override | ||
| 82 | public ArgumentList getArgumentList() | ||
| 83 | { | ||
| 84 | return argumentList; | ||
| 85 | } | ||
| 86 | |||
| 87 | /** | ||
| 88 | * <!-- begin-user-doc --> | ||
| 89 | * <!-- end-user-doc --> | ||
| 90 | * @generated | ||
| 91 | */ | ||
| 92 | public NotificationChain basicSetArgumentList(ArgumentList newArgumentList, NotificationChain msgs) | ||
| 93 | { | ||
| 94 | ArgumentList oldArgumentList = argumentList; | ||
| 95 | argumentList = newArgumentList; | ||
| 96 | if (eNotificationRequired()) | ||
| 97 | { | ||
| 98 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST, oldArgumentList, newArgumentList); | ||
| 99 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 100 | } | ||
| 101 | return msgs; | ||
| 102 | } | ||
| 103 | |||
| 104 | /** | ||
| 105 | * <!-- begin-user-doc --> | ||
| 106 | * <!-- end-user-doc --> | ||
| 107 | * @generated | ||
| 108 | */ | ||
| 109 | @Override | ||
| 110 | public void setArgumentList(ArgumentList newArgumentList) | ||
| 111 | { | ||
| 112 | if (newArgumentList != argumentList) | ||
| 113 | { | ||
| 114 | NotificationChain msgs = null; | ||
| 115 | if (argumentList != null) | ||
| 116 | msgs = ((InternalEObject)argumentList).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST, null, msgs); | ||
| 117 | if (newArgumentList != null) | ||
| 118 | msgs = ((InternalEObject)newArgumentList).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST, null, msgs); | ||
| 119 | msgs = basicSetArgumentList(newArgumentList, msgs); | ||
| 120 | if (msgs != null) msgs.dispatch(); | ||
| 121 | } | ||
| 122 | else if (eNotificationRequired()) | ||
| 123 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST, newArgumentList, newArgumentList)); | ||
| 124 | } | ||
| 125 | |||
| 126 | /** | ||
| 127 | * <!-- begin-user-doc --> | ||
| 128 | * <!-- end-user-doc --> | ||
| 129 | * @generated | ||
| 130 | */ | ||
| 131 | @Override | ||
| 132 | public Expression getBody() | ||
| 133 | { | ||
| 134 | return body; | ||
| 135 | } | ||
| 136 | |||
| 137 | /** | ||
| 138 | * <!-- begin-user-doc --> | ||
| 139 | * <!-- end-user-doc --> | ||
| 140 | * @generated | ||
| 141 | */ | ||
| 142 | public NotificationChain basicSetBody(Expression newBody, NotificationChain msgs) | ||
| 143 | { | ||
| 144 | Expression oldBody = body; | ||
| 145 | body = newBody; | ||
| 146 | if (eNotificationRequired()) | ||
| 147 | { | ||
| 148 | ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY, oldBody, newBody); | ||
| 149 | if (msgs == null) msgs = notification; else msgs.add(notification); | ||
| 150 | } | ||
| 151 | return msgs; | ||
| 152 | } | ||
| 153 | |||
| 154 | /** | ||
| 155 | * <!-- begin-user-doc --> | ||
| 156 | * <!-- end-user-doc --> | ||
| 157 | * @generated | ||
| 158 | */ | ||
| 159 | @Override | ||
| 160 | public void setBody(Expression newBody) | ||
| 161 | { | ||
| 162 | if (newBody != body) | ||
| 163 | { | ||
| 164 | NotificationChain msgs = null; | ||
| 165 | if (body != null) | ||
| 166 | msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY, null, msgs); | ||
| 167 | if (newBody != null) | ||
| 168 | msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY, null, msgs); | ||
| 169 | msgs = basicSetBody(newBody, msgs); | ||
| 170 | if (msgs != null) msgs.dispatch(); | ||
| 171 | } | ||
| 172 | else if (eNotificationRequired()) | ||
| 173 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY, newBody, newBody)); | ||
| 174 | } | ||
| 175 | |||
| 176 | /** | ||
| 177 | * <!-- begin-user-doc --> | ||
| 178 | * <!-- end-user-doc --> | ||
| 179 | * @generated | ||
| 180 | */ | ||
| 181 | @Override | ||
| 182 | public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) | ||
| 183 | { | ||
| 184 | switch (featureID) | ||
| 185 | { | ||
| 186 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST: | ||
| 187 | return basicSetArgumentList(null, msgs); | ||
| 188 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY: | ||
| 189 | return basicSetBody(null, msgs); | ||
| 190 | } | ||
| 191 | return super.eInverseRemove(otherEnd, featureID, msgs); | ||
| 192 | } | ||
| 193 | |||
| 194 | /** | ||
| 195 | * <!-- begin-user-doc --> | ||
| 196 | * <!-- end-user-doc --> | ||
| 197 | * @generated | ||
| 198 | */ | ||
| 199 | @Override | ||
| 200 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 201 | { | ||
| 202 | switch (featureID) | ||
| 203 | { | ||
| 204 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST: | ||
| 205 | return getArgumentList(); | ||
| 206 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY: | ||
| 207 | return getBody(); | ||
| 208 | } | ||
| 209 | return super.eGet(featureID, resolve, coreType); | ||
| 210 | } | ||
| 211 | |||
| 212 | /** | ||
| 213 | * <!-- begin-user-doc --> | ||
| 214 | * <!-- end-user-doc --> | ||
| 215 | * @generated | ||
| 216 | */ | ||
| 217 | @Override | ||
| 218 | public void eSet(int featureID, Object newValue) | ||
| 219 | { | ||
| 220 | switch (featureID) | ||
| 221 | { | ||
| 222 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST: | ||
| 223 | setArgumentList((ArgumentList)newValue); | ||
| 224 | return; | ||
| 225 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY: | ||
| 226 | setBody((Expression)newValue); | ||
| 227 | return; | ||
| 228 | } | ||
| 229 | super.eSet(featureID, newValue); | ||
| 230 | } | ||
| 231 | |||
| 232 | /** | ||
| 233 | * <!-- begin-user-doc --> | ||
| 234 | * <!-- end-user-doc --> | ||
| 235 | * @generated | ||
| 236 | */ | ||
| 237 | @Override | ||
| 238 | public void eUnset(int featureID) | ||
| 239 | { | ||
| 240 | switch (featureID) | ||
| 241 | { | ||
| 242 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST: | ||
| 243 | setArgumentList((ArgumentList)null); | ||
| 244 | return; | ||
| 245 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY: | ||
| 246 | setBody((Expression)null); | ||
| 247 | return; | ||
| 248 | } | ||
| 249 | super.eUnset(featureID); | ||
| 250 | } | ||
| 251 | |||
| 252 | /** | ||
| 253 | * <!-- begin-user-doc --> | ||
| 254 | * <!-- end-user-doc --> | ||
| 255 | * @generated | ||
| 256 | */ | ||
| 257 | @Override | ||
| 258 | public boolean eIsSet(int featureID) | ||
| 259 | { | ||
| 260 | switch (featureID) | ||
| 261 | { | ||
| 262 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST: | ||
| 263 | return argumentList != null; | ||
| 264 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY: | ||
| 265 | return body != null; | ||
| 266 | } | ||
| 267 | return super.eIsSet(featureID); | ||
| 268 | } | ||
| 269 | |||
| 270 | } //UnnamedErrorPrediateDefinitionImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java deleted file mode 100644 index 39bec164..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java +++ /dev/null | |||
| @@ -1,179 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Unnamed Object</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl#getName <em>Name</em>}</li> | ||
| 24 | * </ul> | ||
| 25 | * | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public class UnnamedObjectImpl extends ObjectImpl implements UnnamedObject | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @see #getName() | ||
| 35 | * @generated | ||
| 36 | * @ordered | ||
| 37 | */ | ||
| 38 | protected static final String NAME_EDEFAULT = null; | ||
| 39 | |||
| 40 | /** | ||
| 41 | * The cached value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @see #getName() | ||
| 45 | * @generated | ||
| 46 | * @ordered | ||
| 47 | */ | ||
| 48 | protected String name = NAME_EDEFAULT; | ||
| 49 | |||
| 50 | /** | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @generated | ||
| 54 | */ | ||
| 55 | protected UnnamedObjectImpl() | ||
| 56 | { | ||
| 57 | super(); | ||
| 58 | } | ||
| 59 | |||
| 60 | /** | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @generated | ||
| 64 | */ | ||
| 65 | @Override | ||
| 66 | protected EClass eStaticClass() | ||
| 67 | { | ||
| 68 | return SolverLanguagePackage.Literals.UNNAMED_OBJECT; | ||
| 69 | } | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | @Override | ||
| 77 | public String getName() | ||
| 78 | { | ||
| 79 | return name; | ||
| 80 | } | ||
| 81 | |||
| 82 | /** | ||
| 83 | * <!-- begin-user-doc --> | ||
| 84 | * <!-- end-user-doc --> | ||
| 85 | * @generated | ||
| 86 | */ | ||
| 87 | @Override | ||
| 88 | public void setName(String newName) | ||
| 89 | { | ||
| 90 | String oldName = name; | ||
| 91 | name = newName; | ||
| 92 | if (eNotificationRequired()) | ||
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_OBJECT__NAME, oldName, name)); | ||
| 94 | } | ||
| 95 | |||
| 96 | /** | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @generated | ||
| 100 | */ | ||
| 101 | @Override | ||
| 102 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 103 | { | ||
| 104 | switch (featureID) | ||
| 105 | { | ||
| 106 | case SolverLanguagePackage.UNNAMED_OBJECT__NAME: | ||
| 107 | return getName(); | ||
| 108 | } | ||
| 109 | return super.eGet(featureID, resolve, coreType); | ||
| 110 | } | ||
| 111 | |||
| 112 | /** | ||
| 113 | * <!-- begin-user-doc --> | ||
| 114 | * <!-- end-user-doc --> | ||
| 115 | * @generated | ||
| 116 | */ | ||
| 117 | @Override | ||
| 118 | public void eSet(int featureID, Object newValue) | ||
| 119 | { | ||
| 120 | switch (featureID) | ||
| 121 | { | ||
| 122 | case SolverLanguagePackage.UNNAMED_OBJECT__NAME: | ||
| 123 | setName((String)newValue); | ||
| 124 | return; | ||
| 125 | } | ||
| 126 | super.eSet(featureID, newValue); | ||
| 127 | } | ||
| 128 | |||
| 129 | /** | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @generated | ||
| 133 | */ | ||
| 134 | @Override | ||
| 135 | public void eUnset(int featureID) | ||
| 136 | { | ||
| 137 | switch (featureID) | ||
| 138 | { | ||
| 139 | case SolverLanguagePackage.UNNAMED_OBJECT__NAME: | ||
| 140 | setName(NAME_EDEFAULT); | ||
| 141 | return; | ||
| 142 | } | ||
| 143 | super.eUnset(featureID); | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | @Override | ||
| 152 | public boolean eIsSet(int featureID) | ||
| 153 | { | ||
| 154 | switch (featureID) | ||
| 155 | { | ||
| 156 | case SolverLanguagePackage.UNNAMED_OBJECT__NAME: | ||
| 157 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | ||
| 158 | } | ||
| 159 | return super.eIsSet(featureID); | ||
| 160 | } | ||
| 161 | |||
| 162 | /** | ||
| 163 | * <!-- begin-user-doc --> | ||
| 164 | * <!-- end-user-doc --> | ||
| 165 | * @generated | ||
| 166 | */ | ||
| 167 | @Override | ||
| 168 | public String toString() | ||
| 169 | { | ||
| 170 | if (eIsProxy()) return super.toString(); | ||
| 171 | |||
| 172 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 173 | result.append(" (name: "); | ||
| 174 | result.append(name); | ||
| 175 | result.append(')'); | ||
| 176 | return result.toString(); | ||
| 177 | } | ||
| 178 | |||
| 179 | } //UnnamedObjectImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java deleted file mode 100644 index 9a254023..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java +++ /dev/null | |||
| @@ -1,179 +0,0 @@ | |||
| 1 | /** | ||
| 2 | * generated by Xtext 2.18.0.M3 | ||
| 3 | */ | ||
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.impl; | ||
| 5 | |||
| 6 | import org.eclipse.emf.common.notify.Notification; | ||
| 7 | |||
| 8 | import org.eclipse.emf.ecore.EClass; | ||
| 9 | |||
| 10 | import org.eclipse.emf.ecore.impl.ENotificationImpl; | ||
| 11 | |||
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * <!-- begin-user-doc --> | ||
| 17 | * An implementation of the model object '<em><b>Variable</b></em>'. | ||
| 18 | * <!-- end-user-doc --> | ||
| 19 | * <p> | ||
| 20 | * The following features are implemented: | ||
| 21 | * </p> | ||
| 22 | * <ul> | ||
| 23 | * <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl#getName <em>Name</em>}</li> | ||
| 24 | * </ul> | ||
| 25 | * | ||
| 26 | * @generated | ||
| 27 | */ | ||
| 28 | public class VariableImpl extends LiteralImpl implements Variable | ||
| 29 | { | ||
| 30 | /** | ||
| 31 | * The default value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 32 | * <!-- begin-user-doc --> | ||
| 33 | * <!-- end-user-doc --> | ||
| 34 | * @see #getName() | ||
| 35 | * @generated | ||
| 36 | * @ordered | ||
| 37 | */ | ||
| 38 | protected static final String NAME_EDEFAULT = null; | ||
| 39 | |||
| 40 | /** | ||
| 41 | * The cached value of the '{@link #getName() <em>Name</em>}' attribute. | ||
| 42 | * <!-- begin-user-doc --> | ||
| 43 | * <!-- end-user-doc --> | ||
| 44 | * @see #getName() | ||
| 45 | * @generated | ||
| 46 | * @ordered | ||
| 47 | */ | ||
| 48 | protected String name = NAME_EDEFAULT; | ||
| 49 | |||
| 50 | /** | ||
| 51 | * <!-- begin-user-doc --> | ||
| 52 | * <!-- end-user-doc --> | ||
| 53 | * @generated | ||
| 54 | */ | ||
| 55 | protected VariableImpl() | ||
| 56 | { | ||
| 57 | super(); | ||
| 58 | } | ||
| 59 | |||
| 60 | /** | ||
| 61 | * <!-- begin-user-doc --> | ||
| 62 | * <!-- end-user-doc --> | ||
| 63 | * @generated | ||
| 64 | */ | ||
| 65 | @Override | ||
| 66 | protected EClass eStaticClass() | ||
| 67 | { | ||
| 68 | return SolverLanguagePackage.Literals.VARIABLE; | ||
| 69 | } | ||
| 70 | |||
| 71 | /** | ||
| 72 | * <!-- begin-user-doc --> | ||
| 73 | * <!-- end-user-doc --> | ||
| 74 | * @generated | ||
| 75 | */ | ||
| 76 | @Override | ||
| 77 | public String getName() | ||
| 78 | { | ||
| 79 | return name; | ||
| 80 | } | ||
| 81 | |||
| 82 | /** | ||
| 83 | * <!-- begin-user-doc --> | ||
| 84 | * <!-- end-user-doc --> | ||
| 85 | * @generated | ||
| 86 | */ | ||
| 87 | @Override | ||
| 88 | public void setName(String newName) | ||
| 89 | { | ||
| 90 | String oldName = name; | ||
| 91 | name = newName; | ||
| 92 | if (eNotificationRequired()) | ||
| 93 | eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.VARIABLE__NAME, oldName, name)); | ||
| 94 | } | ||
| 95 | |||
| 96 | /** | ||
| 97 | * <!-- begin-user-doc --> | ||
| 98 | * <!-- end-user-doc --> | ||
| 99 | * @generated | ||
| 100 | */ | ||
| 101 | @Override | ||
| 102 | public Object eGet(int featureID, boolean resolve, boolean coreType) | ||
| 103 | { | ||
| 104 | switch (featureID) | ||
| 105 | { | ||
| 106 | case SolverLanguagePackage.VARIABLE__NAME: | ||
| 107 | return getName(); | ||
| 108 | } | ||
| 109 | return super.eGet(featureID, resolve, coreType); | ||
| 110 | } | ||
| 111 | |||
| 112 | /** | ||
| 113 | * <!-- begin-user-doc --> | ||
| 114 | * <!-- end-user-doc --> | ||
| 115 | * @generated | ||
| 116 | */ | ||
| 117 | @Override | ||
| 118 | public void eSet(int featureID, Object newValue) | ||
| 119 | { | ||
| 120 | switch (featureID) | ||
| 121 | { | ||
| 122 | case SolverLanguagePackage.VARIABLE__NAME: | ||
| 123 | setName((String)newValue); | ||
| 124 | return; | ||
| 125 | } | ||
| 126 | super.eSet(featureID, newValue); | ||
| 127 | } | ||
| 128 | |||
| 129 | /** | ||
| 130 | * <!-- begin-user-doc --> | ||
| 131 | * <!-- end-user-doc --> | ||
| 132 | * @generated | ||
| 133 | */ | ||
| 134 | @Override | ||
| 135 | public void eUnset(int featureID) | ||
| 136 | { | ||
| 137 | switch (featureID) | ||
| 138 | { | ||
| 139 | case SolverLanguagePackage.VARIABLE__NAME: | ||
| 140 | setName(NAME_EDEFAULT); | ||
| 141 | return; | ||
| 142 | } | ||
| 143 | super.eUnset(featureID); | ||
| 144 | } | ||
| 145 | |||
| 146 | /** | ||
| 147 | * <!-- begin-user-doc --> | ||
| 148 | * <!-- end-user-doc --> | ||
| 149 | * @generated | ||
| 150 | */ | ||
| 151 | @Override | ||
| 152 | public boolean eIsSet(int featureID) | ||
| 153 | { | ||
| 154 | switch (featureID) | ||
| 155 | { | ||
| 156 | case SolverLanguagePackage.VARIABLE__NAME: | ||
| 157 | return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); | ||
| 158 | } | ||
| 159 | return super.eIsSet(featureID); | ||
| 160 | } | ||
| 161 | |||
| 162 | /** | ||
| 163 | * <!-- begin-user-doc --> | ||
| 164 | * <!-- end-user-doc --> | ||
| 165 | * @generated | ||
| 166 | */ | ||
| 167 | @Override | ||
| 168 | public String toString() | ||
| 169 | { | ||
| 170 | if (eIsProxy()) return super.toString(); | ||
| 171 | |||
| 172 | StringBuilder result = new StringBuilder(super.toString()); | ||
| 173 | result.append(" (name: "); | ||
| 174 | result.append(name); | ||
| 175 | result.append(')'); | ||
| 176 | return result.toString(); | ||
| 177 | } | ||
| 178 | |||
| 179 | } //VariableImpl | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java index 9931598c..37b20718 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.util; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.util; |
| 5 | 5 | ||
| @@ -10,57 +10,7 @@ import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; | |||
| 10 | 10 | ||
| 11 | import org.eclipse.emf.ecore.EObject; | 11 | import org.eclipse.emf.ecore.EObject; |
| 12 | 12 | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 13 | import org.eclipse.viatra.solver.language.solverLanguage.*; |
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | ||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | ||
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.DataObject; | ||
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; | ||
| 28 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | ||
| 29 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | ||
| 30 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | ||
| 31 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | ||
| 32 | import org.eclipse.viatra.solver.language.solverLanguage.False; | ||
| 33 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | ||
| 34 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | ||
| 35 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | ||
| 36 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | ||
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | ||
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | ||
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | ||
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | ||
| 43 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | ||
| 44 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | ||
| 45 | import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; | ||
| 46 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | ||
| 47 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | ||
| 48 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | ||
| 49 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | ||
| 50 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | ||
| 51 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | ||
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
| 53 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 54 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 55 | import org.eclipse.viatra.solver.language.solverLanguage.Statement; | ||
| 56 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | ||
| 57 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | ||
| 58 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 59 | import org.eclipse.viatra.solver.language.solverLanguage.True; | ||
| 60 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | ||
| 61 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | ||
| 62 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | ||
| 63 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 64 | 14 | ||
| 65 | /** | 15 | /** |
| 66 | * <!-- begin-user-doc --> | 16 | * <!-- begin-user-doc --> |
| @@ -136,254 +86,229 @@ public class SolverLanguageAdapterFactory extends AdapterFactoryImpl | |||
| 136 | return createStatementAdapter(); | 86 | return createStatementAdapter(); |
| 137 | } | 87 | } |
| 138 | @Override | 88 | @Override |
| 139 | public Adapter caseBooleanValue(BooleanValue object) | 89 | public Adapter casePredicateDefinition(PredicateDefinition object) |
| 140 | { | 90 | { |
| 141 | return createBooleanValueAdapter(); | 91 | return createPredicateDefinitionAdapter(); |
| 142 | } | 92 | } |
| 143 | @Override | 93 | @Override |
| 144 | public Adapter caseTruthValue(TruthValue object) | 94 | public Adapter caseUnnamedErrorPrediateDefinition(UnnamedErrorPrediateDefinition object) |
| 145 | { | 95 | { |
| 146 | return createTruthValueAdapter(); | 96 | return createUnnamedErrorPrediateDefinitionAdapter(); |
| 147 | } | 97 | } |
| 148 | @Override | 98 | @Override |
| 149 | public Adapter caseInterpretation(Interpretation object) | 99 | public Adapter caseDefaultDefinition(DefaultDefinition object) |
| 150 | { | 100 | { |
| 151 | return createInterpretationAdapter(); | 101 | return createDefaultDefinitionAdapter(); |
| 152 | } | 102 | } |
| 153 | @Override | 103 | @Override |
| 154 | public Adapter caseBasicInterpretation(BasicInterpretation object) | 104 | public Adapter caseExternPredicateDefinition(ExternPredicateDefinition object) |
| 155 | { | 105 | { |
| 156 | return createBasicInterpretationAdapter(); | 106 | return createExternPredicateDefinitionAdapter(); |
| 157 | } | 107 | } |
| 158 | @Override | 108 | @Override |
| 159 | public Adapter caseSymbol(Symbol object) | 109 | public Adapter caseMetricDefinition(MetricDefinition object) |
| 160 | { | 110 | { |
| 161 | return createSymbolAdapter(); | 111 | return createMetricDefinitionAdapter(); |
| 162 | } | 112 | } |
| 163 | @Override | 113 | @Override |
| 164 | public Adapter caseModelSymbol(ModelSymbol object) | 114 | public Adapter caseExternMetricDefinition(ExternMetricDefinition object) |
| 165 | { | 115 | { |
| 166 | return createModelSymbolAdapter(); | 116 | return createExternMetricDefinitionAdapter(); |
| 167 | } | 117 | } |
| 168 | @Override | 118 | @Override |
| 169 | public Adapter casePartialitySymbol(PartialitySymbol object) | 119 | public Adapter caseExpression(Expression object) |
| 170 | { | 120 | { |
| 171 | return createPartialitySymbolAdapter(); | 121 | return createExpressionAdapter(); |
| 172 | } | 122 | } |
| 173 | @Override | 123 | @Override |
| 174 | public Adapter caseExistSymbol(ExistSymbol object) | 124 | public Adapter caseIfElse(IfElse object) |
| 175 | { | 125 | { |
| 176 | return createExistSymbolAdapter(); | 126 | return createIfElseAdapter(); |
| 177 | } | 127 | } |
| 178 | @Override | 128 | @Override |
| 179 | public Adapter caseEqualsSymbol(EqualsSymbol object) | 129 | public Adapter caseCase(Case object) |
| 180 | { | 130 | { |
| 181 | return createEqualsSymbolAdapter(); | 131 | return createCaseAdapter(); |
| 182 | } | 132 | } |
| 183 | @Override | 133 | @Override |
| 184 | public Adapter caseDataSymbol(DataSymbol object) | 134 | public Adapter caseCount(Count object) |
| 185 | { | 135 | { |
| 186 | return createDataSymbolAdapter(); | 136 | return createCountAdapter(); |
| 187 | } | 137 | } |
| 188 | @Override | 138 | @Override |
| 189 | public Adapter caseBooleanSymbol(BooleanSymbol object) | 139 | public Adapter caseAggregation(Aggregation object) |
| 190 | { | 140 | { |
| 191 | return createBooleanSymbolAdapter(); | 141 | return createAggregationAdapter(); |
| 192 | } | 142 | } |
| 193 | @Override | 143 | @Override |
| 194 | public Adapter caseIntegerSymbol(IntegerSymbol object) | 144 | public Adapter caseCall(Call object) |
| 195 | { | 145 | { |
| 196 | return createIntegerSymbolAdapter(); | 146 | return createCallAdapter(); |
| 197 | } | 147 | } |
| 198 | @Override | 148 | @Override |
| 199 | public Adapter caseRealSymbol(RealSymbol object) | 149 | public Adapter caseArgumentList(ArgumentList object) |
| 200 | { | 150 | { |
| 201 | return createRealSymbolAdapter(); | 151 | return createArgumentListAdapter(); |
| 202 | } | 152 | } |
| 203 | @Override | 153 | @Override |
| 204 | public Adapter caseStringSymbol(StringSymbol object) | 154 | public Adapter caseArgument(Argument object) |
| 205 | { | 155 | { |
| 206 | return createStringSymbolAdapter(); | 156 | return createArgumentAdapter(); |
| 207 | } | 157 | } |
| 208 | @Override | 158 | @Override |
| 209 | public Adapter caseComplexObject(ComplexObject object) | 159 | public Adapter caseExpressionArgument(ExpressionArgument object) |
| 210 | { | 160 | { |
| 211 | return createComplexObjectAdapter(); | 161 | return createExpressionArgumentAdapter(); |
| 212 | } | 162 | } |
| 213 | @Override | 163 | @Override |
| 214 | public Adapter caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object) | 164 | public Adapter caseStarArgument(StarArgument object) |
| 215 | { | 165 | { |
| 216 | return createObjectAdapter(); | 166 | return createStarArgumentAdapter(); |
| 217 | } | 167 | } |
| 218 | @Override | 168 | @Override |
| 219 | public Adapter caseNamedObject(NamedObject object) | 169 | public Adapter caseTypedArgument(TypedArgument object) |
| 220 | { | 170 | { |
| 221 | return createNamedObjectAdapter(); | 171 | return createTypedArgumentAdapter(); |
| 222 | } | 172 | } |
| 223 | @Override | 173 | @Override |
| 224 | public Adapter caseUnnamedObject(UnnamedObject object) | 174 | public Adapter caseTypedStarArgument(TypedStarArgument object) |
| 225 | { | 175 | { |
| 226 | return createUnnamedObjectAdapter(); | 176 | return createTypedStarArgumentAdapter(); |
| 227 | } | 177 | } |
| 228 | @Override | 178 | @Override |
| 229 | public Adapter caseDataObject(DataObject object) | 179 | public Adapter caseReference(Reference object) |
| 230 | { | 180 | { |
| 231 | return createDataObjectAdapter(); | 181 | return createReferenceAdapter(); |
| 232 | } | 182 | } |
| 233 | @Override | 183 | @Override |
| 234 | public Adapter caseBooleanObject(BooleanObject object) | 184 | public Adapter caseInterval(Interval object) |
| 235 | { | 185 | { |
| 236 | return createBooleanObjectAdapter(); | 186 | return createIntervalAdapter(); |
| 237 | } | 187 | } |
| 238 | @Override | 188 | @Override |
| 239 | public Adapter caseIntObject(IntObject object) | 189 | public Adapter caseLiteral(Literal object) |
| 240 | { | ||
| 241 | return createIntObjectAdapter(); | ||
| 242 | } | ||
| 243 | @Override | ||
| 244 | public Adapter caseRealObject(RealObject object) | ||
| 245 | { | ||
| 246 | return createRealObjectAdapter(); | ||
| 247 | } | ||
| 248 | @Override | ||
| 249 | public Adapter caseStringObject(StringObject object) | ||
| 250 | { | ||
| 251 | return createStringObjectAdapter(); | ||
| 252 | } | ||
| 253 | @Override | ||
| 254 | public Adapter casePredicate(Predicate object) | ||
| 255 | { | ||
| 256 | return createPredicateAdapter(); | ||
| 257 | } | ||
| 258 | @Override | ||
| 259 | public Adapter caseParameter(Parameter object) | ||
| 260 | { | 190 | { |
| 261 | return createParameterAdapter(); | 191 | return createLiteralAdapter(); |
| 262 | } | 192 | } |
| 263 | @Override | 193 | @Override |
| 264 | public Adapter casePatternBody(PatternBody object) | 194 | public Adapter caseLogicLiteral(LogicLiteral object) |
| 265 | { | 195 | { |
| 266 | return createPatternBodyAdapter(); | 196 | return createLogicLiteralAdapter(); |
| 267 | } | 197 | } |
| 268 | @Override | 198 | @Override |
| 269 | public Adapter casePolarity(Polarity object) | 199 | public Adapter caseNumericLiteral(NumericLiteral object) |
| 270 | { | 200 | { |
| 271 | return createPolarityAdapter(); | 201 | return createNumericLiteralAdapter(); |
| 272 | } | 202 | } |
| 273 | @Override | 203 | @Override |
| 274 | public Adapter caseConstraint(Constraint object) | 204 | public Adapter caseInfinityLiteral(InfinityLiteral object) |
| 275 | { | 205 | { |
| 276 | return createConstraintAdapter(); | 206 | return createInfinityLiteralAdapter(); |
| 277 | } | 207 | } |
| 278 | @Override | 208 | @Override |
| 279 | public Adapter caseClosureType(ClosureType object) | 209 | public Adapter caseEmptyIntervalLiteral(EmptyIntervalLiteral object) |
| 280 | { | 210 | { |
| 281 | return createClosureTypeAdapter(); | 211 | return createEmptyIntervalLiteralAdapter(); |
| 282 | } | 212 | } |
| 283 | @Override | 213 | @Override |
| 284 | public Adapter caseLiteral(Literal object) | 214 | public Adapter caseStringLiteral(StringLiteral object) |
| 285 | { | 215 | { |
| 286 | return createLiteralAdapter(); | 216 | return createStringLiteralAdapter(); |
| 287 | } | 217 | } |
| 288 | @Override | 218 | @Override |
| 289 | public Adapter caseVariable(Variable object) | 219 | public Adapter caseClassDefinition(ClassDefinition object) |
| 290 | { | 220 | { |
| 291 | return createVariableAdapter(); | 221 | return createClassDefinitionAdapter(); |
| 292 | } | 222 | } |
| 293 | @Override | 223 | @Override |
| 294 | public Adapter caseAllInstances(AllInstances object) | 224 | public Adapter caseMemberDefinition(MemberDefinition object) |
| 295 | { | 225 | { |
| 296 | return createAllInstancesAdapter(); | 226 | return createMemberDefinitionAdapter(); |
| 297 | } | 227 | } |
| 298 | @Override | 228 | @Override |
| 299 | public Adapter caseAllObjects(AllObjects object) | 229 | public Adapter caseMultiplicity(Multiplicity object) |
| 300 | { | 230 | { |
| 301 | return createAllObjectsAdapter(); | 231 | return createMultiplicityAdapter(); |
| 302 | } | 232 | } |
| 303 | @Override | 233 | @Override |
| 304 | public Adapter caseDefaultInterpretation(DefaultInterpretation object) | 234 | public Adapter caseManyMultiplicity(ManyMultiplicity object) |
| 305 | { | 235 | { |
| 306 | return createDefaultInterpretationAdapter(); | 236 | return createManyMultiplicityAdapter(); |
| 307 | } | 237 | } |
| 308 | @Override | 238 | @Override |
| 309 | public Adapter caseCDInterpretation(CDInterpretation object) | 239 | public Adapter caseExactMultiplicity(ExactMultiplicity object) |
| 310 | { | 240 | { |
| 311 | return createCDInterpretationAdapter(); | 241 | return createExactMultiplicityAdapter(); |
| 312 | } | 242 | } |
| 313 | @Override | 243 | @Override |
| 314 | public Adapter caseClassInterpretation(ClassInterpretation object) | 244 | public Adapter caseBoundedMultiplicity(BoundedMultiplicity object) |
| 315 | { | 245 | { |
| 316 | return createClassInterpretationAdapter(); | 246 | return createBoundedMultiplicityAdapter(); |
| 317 | } | 247 | } |
| 318 | @Override | 248 | @Override |
| 319 | public Adapter caseEnumInterpretation(EnumInterpretation object) | 249 | public Adapter caseScopeDefinition(ScopeDefinition object) |
| 320 | { | 250 | { |
| 321 | return createEnumInterpretationAdapter(); | 251 | return createScopeDefinitionAdapter(); |
| 322 | } | 252 | } |
| 323 | @Override | 253 | @Override |
| 324 | public Adapter caseFieldRelationInterpretation(FieldRelationInterpretation object) | 254 | public Adapter caseExactScopeDefinition(ExactScopeDefinition object) |
| 325 | { | 255 | { |
| 326 | return createFieldRelationInterpretationAdapter(); | 256 | return createExactScopeDefinitionAdapter(); |
| 327 | } | 257 | } |
| 328 | @Override | 258 | @Override |
| 329 | public Adapter caseGlobalRelationInterpretation(GlobalRelationInterpretation object) | 259 | public Adapter caseBoundedScopeDefinition(BoundedScopeDefinition object) |
| 330 | { | 260 | { |
| 331 | return createGlobalRelationInterpretationAdapter(); | 261 | return createBoundedScopeDefinitionAdapter(); |
| 332 | } | 262 | } |
| 333 | @Override | 263 | @Override |
| 334 | public Adapter caseMultiplicityDefinition(MultiplicityDefinition object) | 264 | public Adapter caseLowerBoundedScopeDefinition(LowerBoundedScopeDefinition object) |
| 335 | { | 265 | { |
| 336 | return createMultiplicityDefinitionAdapter(); | 266 | return createLowerBoundedScopeDefinitionAdapter(); |
| 337 | } | 267 | } |
| 338 | @Override | 268 | @Override |
| 339 | public Adapter caseBooleanTrue(BooleanTrue object) | 269 | public Adapter caseObjectiveDefinition(ObjectiveDefinition object) |
| 340 | { | 270 | { |
| 341 | return createBooleanTrueAdapter(); | 271 | return createObjectiveDefinitionAdapter(); |
| 342 | } | 272 | } |
| 343 | @Override | 273 | @Override |
| 344 | public Adapter caseBooleanFalse(BooleanFalse object) | 274 | public Adapter caseNamedElement(NamedElement object) |
| 345 | { | 275 | { |
| 346 | return createBooleanFalseAdapter(); | 276 | return createNamedElementAdapter(); |
| 347 | } | 277 | } |
| 348 | @Override | 278 | @Override |
| 349 | public Adapter caseTrue(True object) | 279 | public Adapter caseAssertion(Assertion object) |
| 350 | { | 280 | { |
| 351 | return createTrueAdapter(); | 281 | return createAssertionAdapter(); |
| 352 | } | 282 | } |
| 353 | @Override | 283 | @Override |
| 354 | public Adapter caseFalse(False object) | 284 | public Adapter caseDisjunction(Disjunction object) |
| 355 | { | 285 | { |
| 356 | return createFalseAdapter(); | 286 | return createDisjunctionAdapter(); |
| 357 | } | 287 | } |
| 358 | @Override | 288 | @Override |
| 359 | public Adapter caseUnknown(Unknown object) | 289 | public Adapter caseSwitch(Switch object) |
| 360 | { | 290 | { |
| 361 | return createUnknownAdapter(); | 291 | return createSwitchAdapter(); |
| 362 | } | 292 | } |
| 363 | @Override | 293 | @Override |
| 364 | public Adapter caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object) | 294 | public Adapter caseConjunction(Conjunction object) |
| 365 | { | 295 | { |
| 366 | return createErrorAdapter(); | 296 | return createConjunctionAdapter(); |
| 367 | } | 297 | } |
| 368 | @Override | 298 | @Override |
| 369 | public Adapter casePositive(Positive object) | 299 | public Adapter caseComparison(Comparison object) |
| 370 | { | 300 | { |
| 371 | return createPositiveAdapter(); | 301 | return createComparisonAdapter(); |
| 372 | } | 302 | } |
| 373 | @Override | 303 | @Override |
| 374 | public Adapter caseNegative(Negative object) | 304 | public Adapter caseBinaryExpression(BinaryExpression object) |
| 375 | { | 305 | { |
| 376 | return createNegativeAdapter(); | 306 | return createBinaryExpressionAdapter(); |
| 377 | } | 307 | } |
| 378 | @Override | 308 | @Override |
| 379 | public Adapter caseReflexiveClosure(ReflexiveClosure object) | 309 | public Adapter caseUnaryExpression(UnaryExpression object) |
| 380 | { | 310 | { |
| 381 | return createReflexiveClosureAdapter(); | 311 | return createUnaryExpressionAdapter(); |
| 382 | } | ||
| 383 | @Override | ||
| 384 | public Adapter caseIrreflexiveClosure(IrreflexiveClosure object) | ||
| 385 | { | ||
| 386 | return createIrreflexiveClosureAdapter(); | ||
| 387 | } | 312 | } |
| 388 | @Override | 313 | @Override |
| 389 | public Adapter defaultCase(EObject object) | 314 | public Adapter defaultCase(EObject object) |
| @@ -438,751 +363,676 @@ public class SolverLanguageAdapterFactory extends AdapterFactoryImpl | |||
| 438 | } | 363 | } |
| 439 | 364 | ||
| 440 | /** | 365 | /** |
| 441 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue <em>Boolean Value</em>}'. | 366 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition <em>Predicate Definition</em>}'. |
| 442 | * <!-- begin-user-doc --> | ||
| 443 | * This default implementation returns null so that we can easily ignore cases; | ||
| 444 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
| 445 | * <!-- end-user-doc --> | ||
| 446 | * @return the new adapter. | ||
| 447 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue | ||
| 448 | * @generated | ||
| 449 | */ | ||
| 450 | public Adapter createBooleanValueAdapter() | ||
| 451 | { | ||
| 452 | return null; | ||
| 453 | } | ||
| 454 | |||
| 455 | /** | ||
| 456 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue <em>Truth Value</em>}'. | ||
| 457 | * <!-- begin-user-doc --> | ||
| 458 | * This default implementation returns null so that we can easily ignore cases; | ||
| 459 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
| 460 | * <!-- end-user-doc --> | ||
| 461 | * @return the new adapter. | ||
| 462 | * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue | ||
| 463 | * @generated | ||
| 464 | */ | ||
| 465 | public Adapter createTruthValueAdapter() | ||
| 466 | { | ||
| 467 | return null; | ||
| 468 | } | ||
| 469 | |||
| 470 | /** | ||
| 471 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation <em>Interpretation</em>}'. | ||
| 472 | * <!-- begin-user-doc --> | 367 | * <!-- begin-user-doc --> |
| 473 | * This default implementation returns null so that we can easily ignore cases; | 368 | * This default implementation returns null so that we can easily ignore cases; |
| 474 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 369 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 475 | * <!-- end-user-doc --> | 370 | * <!-- end-user-doc --> |
| 476 | * @return the new adapter. | 371 | * @return the new adapter. |
| 477 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation | 372 | * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition |
| 478 | * @generated | 373 | * @generated |
| 479 | */ | 374 | */ |
| 480 | public Adapter createInterpretationAdapter() | 375 | public Adapter createPredicateDefinitionAdapter() |
| 481 | { | 376 | { |
| 482 | return null; | 377 | return null; |
| 483 | } | 378 | } |
| 484 | 379 | ||
| 485 | /** | 380 | /** |
| 486 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation <em>Basic Interpretation</em>}'. | 381 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition <em>Unnamed Error Prediate Definition</em>}'. |
| 487 | * <!-- begin-user-doc --> | 382 | * <!-- begin-user-doc --> |
| 488 | * This default implementation returns null so that we can easily ignore cases; | 383 | * This default implementation returns null so that we can easily ignore cases; |
| 489 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 384 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 490 | * <!-- end-user-doc --> | 385 | * <!-- end-user-doc --> |
| 491 | * @return the new adapter. | 386 | * @return the new adapter. |
| 492 | * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation | 387 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition |
| 493 | * @generated | 388 | * @generated |
| 494 | */ | 389 | */ |
| 495 | public Adapter createBasicInterpretationAdapter() | 390 | public Adapter createUnnamedErrorPrediateDefinitionAdapter() |
| 496 | { | 391 | { |
| 497 | return null; | 392 | return null; |
| 498 | } | 393 | } |
| 499 | 394 | ||
| 500 | /** | 395 | /** |
| 501 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol <em>Symbol</em>}'. | 396 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition <em>Default Definition</em>}'. |
| 502 | * <!-- begin-user-doc --> | 397 | * <!-- begin-user-doc --> |
| 503 | * This default implementation returns null so that we can easily ignore cases; | 398 | * This default implementation returns null so that we can easily ignore cases; |
| 504 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 399 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 505 | * <!-- end-user-doc --> | 400 | * <!-- end-user-doc --> |
| 506 | * @return the new adapter. | 401 | * @return the new adapter. |
| 507 | * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol | 402 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition |
| 508 | * @generated | 403 | * @generated |
| 509 | */ | 404 | */ |
| 510 | public Adapter createSymbolAdapter() | 405 | public Adapter createDefaultDefinitionAdapter() |
| 511 | { | 406 | { |
| 512 | return null; | 407 | return null; |
| 513 | } | 408 | } |
| 514 | 409 | ||
| 515 | /** | 410 | /** |
| 516 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol <em>Model Symbol</em>}'. | 411 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition <em>Extern Predicate Definition</em>}'. |
| 517 | * <!-- begin-user-doc --> | 412 | * <!-- begin-user-doc --> |
| 518 | * This default implementation returns null so that we can easily ignore cases; | 413 | * This default implementation returns null so that we can easily ignore cases; |
| 519 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 414 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 520 | * <!-- end-user-doc --> | 415 | * <!-- end-user-doc --> |
| 521 | * @return the new adapter. | 416 | * @return the new adapter. |
| 522 | * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol | 417 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition |
| 523 | * @generated | 418 | * @generated |
| 524 | */ | 419 | */ |
| 525 | public Adapter createModelSymbolAdapter() | 420 | public Adapter createExternPredicateDefinitionAdapter() |
| 526 | { | 421 | { |
| 527 | return null; | 422 | return null; |
| 528 | } | 423 | } |
| 529 | 424 | ||
| 530 | /** | 425 | /** |
| 531 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol <em>Partiality Symbol</em>}'. | 426 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition <em>Metric Definition</em>}'. |
| 532 | * <!-- begin-user-doc --> | 427 | * <!-- begin-user-doc --> |
| 533 | * This default implementation returns null so that we can easily ignore cases; | 428 | * This default implementation returns null so that we can easily ignore cases; |
| 534 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 429 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 535 | * <!-- end-user-doc --> | 430 | * <!-- end-user-doc --> |
| 536 | * @return the new adapter. | 431 | * @return the new adapter. |
| 537 | * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol | 432 | * @see org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition |
| 538 | * @generated | 433 | * @generated |
| 539 | */ | 434 | */ |
| 540 | public Adapter createPartialitySymbolAdapter() | 435 | public Adapter createMetricDefinitionAdapter() |
| 541 | { | 436 | { |
| 542 | return null; | 437 | return null; |
| 543 | } | 438 | } |
| 544 | 439 | ||
| 545 | /** | 440 | /** |
| 546 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol <em>Exist Symbol</em>}'. | 441 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition <em>Extern Metric Definition</em>}'. |
| 547 | * <!-- begin-user-doc --> | 442 | * <!-- begin-user-doc --> |
| 548 | * This default implementation returns null so that we can easily ignore cases; | 443 | * This default implementation returns null so that we can easily ignore cases; |
| 549 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 444 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 550 | * <!-- end-user-doc --> | 445 | * <!-- end-user-doc --> |
| 551 | * @return the new adapter. | 446 | * @return the new adapter. |
| 552 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol | 447 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition |
| 553 | * @generated | 448 | * @generated |
| 554 | */ | 449 | */ |
| 555 | public Adapter createExistSymbolAdapter() | 450 | public Adapter createExternMetricDefinitionAdapter() |
| 556 | { | 451 | { |
| 557 | return null; | 452 | return null; |
| 558 | } | 453 | } |
| 559 | 454 | ||
| 560 | /** | 455 | /** |
| 561 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol <em>Equals Symbol</em>}'. | 456 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Expression <em>Expression</em>}'. |
| 562 | * <!-- begin-user-doc --> | 457 | * <!-- begin-user-doc --> |
| 563 | * This default implementation returns null so that we can easily ignore cases; | 458 | * This default implementation returns null so that we can easily ignore cases; |
| 564 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 459 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 565 | * <!-- end-user-doc --> | 460 | * <!-- end-user-doc --> |
| 566 | * @return the new adapter. | 461 | * @return the new adapter. |
| 567 | * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol | 462 | * @see org.eclipse.viatra.solver.language.solverLanguage.Expression |
| 568 | * @generated | 463 | * @generated |
| 569 | */ | 464 | */ |
| 570 | public Adapter createEqualsSymbolAdapter() | 465 | public Adapter createExpressionAdapter() |
| 571 | { | 466 | { |
| 572 | return null; | 467 | return null; |
| 573 | } | 468 | } |
| 574 | 469 | ||
| 575 | /** | 470 | /** |
| 576 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol <em>Data Symbol</em>}'. | 471 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IfElse <em>If Else</em>}'. |
| 577 | * <!-- begin-user-doc --> | 472 | * <!-- begin-user-doc --> |
| 578 | * This default implementation returns null so that we can easily ignore cases; | 473 | * This default implementation returns null so that we can easily ignore cases; |
| 579 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 474 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 580 | * <!-- end-user-doc --> | 475 | * <!-- end-user-doc --> |
| 581 | * @return the new adapter. | 476 | * @return the new adapter. |
| 582 | * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol | 477 | * @see org.eclipse.viatra.solver.language.solverLanguage.IfElse |
| 583 | * @generated | 478 | * @generated |
| 584 | */ | 479 | */ |
| 585 | public Adapter createDataSymbolAdapter() | 480 | public Adapter createIfElseAdapter() |
| 586 | { | 481 | { |
| 587 | return null; | 482 | return null; |
| 588 | } | 483 | } |
| 589 | 484 | ||
| 590 | /** | 485 | /** |
| 591 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol <em>Boolean Symbol</em>}'. | 486 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Case <em>Case</em>}'. |
| 592 | * <!-- begin-user-doc --> | 487 | * <!-- begin-user-doc --> |
| 593 | * This default implementation returns null so that we can easily ignore cases; | 488 | * This default implementation returns null so that we can easily ignore cases; |
| 594 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 489 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 595 | * <!-- end-user-doc --> | 490 | * <!-- end-user-doc --> |
| 596 | * @return the new adapter. | 491 | * @return the new adapter. |
| 597 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol | 492 | * @see org.eclipse.viatra.solver.language.solverLanguage.Case |
| 598 | * @generated | 493 | * @generated |
| 599 | */ | 494 | */ |
| 600 | public Adapter createBooleanSymbolAdapter() | 495 | public Adapter createCaseAdapter() |
| 601 | { | 496 | { |
| 602 | return null; | 497 | return null; |
| 603 | } | 498 | } |
| 604 | 499 | ||
| 605 | /** | 500 | /** |
| 606 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol <em>Integer Symbol</em>}'. | 501 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Count <em>Count</em>}'. |
| 607 | * <!-- begin-user-doc --> | 502 | * <!-- begin-user-doc --> |
| 608 | * This default implementation returns null so that we can easily ignore cases; | 503 | * This default implementation returns null so that we can easily ignore cases; |
| 609 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 504 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 610 | * <!-- end-user-doc --> | 505 | * <!-- end-user-doc --> |
| 611 | * @return the new adapter. | 506 | * @return the new adapter. |
| 612 | * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol | 507 | * @see org.eclipse.viatra.solver.language.solverLanguage.Count |
| 613 | * @generated | 508 | * @generated |
| 614 | */ | 509 | */ |
| 615 | public Adapter createIntegerSymbolAdapter() | 510 | public Adapter createCountAdapter() |
| 616 | { | 511 | { |
| 617 | return null; | 512 | return null; |
| 618 | } | 513 | } |
| 619 | 514 | ||
| 620 | /** | 515 | /** |
| 621 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol <em>Real Symbol</em>}'. | 516 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Aggregation <em>Aggregation</em>}'. |
| 622 | * <!-- begin-user-doc --> | 517 | * <!-- begin-user-doc --> |
| 623 | * This default implementation returns null so that we can easily ignore cases; | 518 | * This default implementation returns null so that we can easily ignore cases; |
| 624 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 519 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 625 | * <!-- end-user-doc --> | 520 | * <!-- end-user-doc --> |
| 626 | * @return the new adapter. | 521 | * @return the new adapter. |
| 627 | * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol | 522 | * @see org.eclipse.viatra.solver.language.solverLanguage.Aggregation |
| 628 | * @generated | 523 | * @generated |
| 629 | */ | 524 | */ |
| 630 | public Adapter createRealSymbolAdapter() | 525 | public Adapter createAggregationAdapter() |
| 631 | { | 526 | { |
| 632 | return null; | 527 | return null; |
| 633 | } | 528 | } |
| 634 | 529 | ||
| 635 | /** | 530 | /** |
| 636 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol <em>String Symbol</em>}'. | 531 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Call <em>Call</em>}'. |
| 637 | * <!-- begin-user-doc --> | 532 | * <!-- begin-user-doc --> |
| 638 | * This default implementation returns null so that we can easily ignore cases; | 533 | * This default implementation returns null so that we can easily ignore cases; |
| 639 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 534 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 640 | * <!-- end-user-doc --> | 535 | * <!-- end-user-doc --> |
| 641 | * @return the new adapter. | 536 | * @return the new adapter. |
| 642 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol | 537 | * @see org.eclipse.viatra.solver.language.solverLanguage.Call |
| 643 | * @generated | 538 | * @generated |
| 644 | */ | 539 | */ |
| 645 | public Adapter createStringSymbolAdapter() | 540 | public Adapter createCallAdapter() |
| 646 | { | 541 | { |
| 647 | return null; | 542 | return null; |
| 648 | } | 543 | } |
| 649 | 544 | ||
| 650 | /** | 545 | /** |
| 651 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject <em>Complex Object</em>}'. | 546 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ArgumentList <em>Argument List</em>}'. |
| 652 | * <!-- begin-user-doc --> | 547 | * <!-- begin-user-doc --> |
| 653 | * This default implementation returns null so that we can easily ignore cases; | 548 | * This default implementation returns null so that we can easily ignore cases; |
| 654 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 549 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 655 | * <!-- end-user-doc --> | 550 | * <!-- end-user-doc --> |
| 656 | * @return the new adapter. | 551 | * @return the new adapter. |
| 657 | * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject | 552 | * @see org.eclipse.viatra.solver.language.solverLanguage.ArgumentList |
| 658 | * @generated | 553 | * @generated |
| 659 | */ | 554 | */ |
| 660 | public Adapter createComplexObjectAdapter() | 555 | public Adapter createArgumentListAdapter() |
| 661 | { | 556 | { |
| 662 | return null; | 557 | return null; |
| 663 | } | 558 | } |
| 664 | 559 | ||
| 665 | /** | 560 | /** |
| 666 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object <em>Object</em>}'. | 561 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Argument <em>Argument</em>}'. |
| 667 | * <!-- begin-user-doc --> | 562 | * <!-- begin-user-doc --> |
| 668 | * This default implementation returns null so that we can easily ignore cases; | 563 | * This default implementation returns null so that we can easily ignore cases; |
| 669 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 564 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 670 | * <!-- end-user-doc --> | 565 | * <!-- end-user-doc --> |
| 671 | * @return the new adapter. | 566 | * @return the new adapter. |
| 672 | * @see org.eclipse.viatra.solver.language.solverLanguage.Object | 567 | * @see org.eclipse.viatra.solver.language.solverLanguage.Argument |
| 673 | * @generated | 568 | * @generated |
| 674 | */ | 569 | */ |
| 675 | public Adapter createObjectAdapter() | 570 | public Adapter createArgumentAdapter() |
| 676 | { | 571 | { |
| 677 | return null; | 572 | return null; |
| 678 | } | 573 | } |
| 679 | 574 | ||
| 680 | /** | 575 | /** |
| 681 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject <em>Named Object</em>}'. | 576 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument <em>Expression Argument</em>}'. |
| 682 | * <!-- begin-user-doc --> | 577 | * <!-- begin-user-doc --> |
| 683 | * This default implementation returns null so that we can easily ignore cases; | 578 | * This default implementation returns null so that we can easily ignore cases; |
| 684 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 579 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 685 | * <!-- end-user-doc --> | 580 | * <!-- end-user-doc --> |
| 686 | * @return the new adapter. | 581 | * @return the new adapter. |
| 687 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject | 582 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument |
| 688 | * @generated | 583 | * @generated |
| 689 | */ | 584 | */ |
| 690 | public Adapter createNamedObjectAdapter() | 585 | public Adapter createExpressionArgumentAdapter() |
| 691 | { | 586 | { |
| 692 | return null; | 587 | return null; |
| 693 | } | 588 | } |
| 694 | 589 | ||
| 695 | /** | 590 | /** |
| 696 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject <em>Unnamed Object</em>}'. | 591 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StarArgument <em>Star Argument</em>}'. |
| 697 | * <!-- begin-user-doc --> | 592 | * <!-- begin-user-doc --> |
| 698 | * This default implementation returns null so that we can easily ignore cases; | 593 | * This default implementation returns null so that we can easily ignore cases; |
| 699 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 594 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 700 | * <!-- end-user-doc --> | 595 | * <!-- end-user-doc --> |
| 701 | * @return the new adapter. | 596 | * @return the new adapter. |
| 702 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject | 597 | * @see org.eclipse.viatra.solver.language.solverLanguage.StarArgument |
| 703 | * @generated | 598 | * @generated |
| 704 | */ | 599 | */ |
| 705 | public Adapter createUnnamedObjectAdapter() | 600 | public Adapter createStarArgumentAdapter() |
| 706 | { | 601 | { |
| 707 | return null; | 602 | return null; |
| 708 | } | 603 | } |
| 709 | 604 | ||
| 710 | /** | 605 | /** |
| 711 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject <em>Data Object</em>}'. | 606 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedArgument <em>Typed Argument</em>}'. |
| 712 | * <!-- begin-user-doc --> | 607 | * <!-- begin-user-doc --> |
| 713 | * This default implementation returns null so that we can easily ignore cases; | 608 | * This default implementation returns null so that we can easily ignore cases; |
| 714 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 609 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 715 | * <!-- end-user-doc --> | 610 | * <!-- end-user-doc --> |
| 716 | * @return the new adapter. | 611 | * @return the new adapter. |
| 717 | * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject | 612 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedArgument |
| 718 | * @generated | 613 | * @generated |
| 719 | */ | 614 | */ |
| 720 | public Adapter createDataObjectAdapter() | 615 | public Adapter createTypedArgumentAdapter() |
| 721 | { | 616 | { |
| 722 | return null; | 617 | return null; |
| 723 | } | 618 | } |
| 724 | 619 | ||
| 725 | /** | 620 | /** |
| 726 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject <em>Boolean Object</em>}'. | 621 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument <em>Typed Star Argument</em>}'. |
| 727 | * <!-- begin-user-doc --> | 622 | * <!-- begin-user-doc --> |
| 728 | * This default implementation returns null so that we can easily ignore cases; | 623 | * This default implementation returns null so that we can easily ignore cases; |
| 729 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 624 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 730 | * <!-- end-user-doc --> | 625 | * <!-- end-user-doc --> |
| 731 | * @return the new adapter. | 626 | * @return the new adapter. |
| 732 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject | 627 | * @see org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument |
| 733 | * @generated | 628 | * @generated |
| 734 | */ | 629 | */ |
| 735 | public Adapter createBooleanObjectAdapter() | 630 | public Adapter createTypedStarArgumentAdapter() |
| 736 | { | 631 | { |
| 737 | return null; | 632 | return null; |
| 738 | } | 633 | } |
| 739 | 634 | ||
| 740 | /** | 635 | /** |
| 741 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject <em>Int Object</em>}'. | 636 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Reference <em>Reference</em>}'. |
| 742 | * <!-- begin-user-doc --> | 637 | * <!-- begin-user-doc --> |
| 743 | * This default implementation returns null so that we can easily ignore cases; | 638 | * This default implementation returns null so that we can easily ignore cases; |
| 744 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 639 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 745 | * <!-- end-user-doc --> | 640 | * <!-- end-user-doc --> |
| 746 | * @return the new adapter. | 641 | * @return the new adapter. |
| 747 | * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject | 642 | * @see org.eclipse.viatra.solver.language.solverLanguage.Reference |
| 748 | * @generated | 643 | * @generated |
| 749 | */ | 644 | */ |
| 750 | public Adapter createIntObjectAdapter() | 645 | public Adapter createReferenceAdapter() |
| 751 | { | 646 | { |
| 752 | return null; | 647 | return null; |
| 753 | } | 648 | } |
| 754 | 649 | ||
| 755 | /** | 650 | /** |
| 756 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject <em>Real Object</em>}'. | 651 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interval <em>Interval</em>}'. |
| 757 | * <!-- begin-user-doc --> | 652 | * <!-- begin-user-doc --> |
| 758 | * This default implementation returns null so that we can easily ignore cases; | 653 | * This default implementation returns null so that we can easily ignore cases; |
| 759 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 654 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 760 | * <!-- end-user-doc --> | 655 | * <!-- end-user-doc --> |
| 761 | * @return the new adapter. | 656 | * @return the new adapter. |
| 762 | * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject | 657 | * @see org.eclipse.viatra.solver.language.solverLanguage.Interval |
| 763 | * @generated | 658 | * @generated |
| 764 | */ | 659 | */ |
| 765 | public Adapter createRealObjectAdapter() | 660 | public Adapter createIntervalAdapter() |
| 766 | { | 661 | { |
| 767 | return null; | 662 | return null; |
| 768 | } | 663 | } |
| 769 | 664 | ||
| 770 | /** | 665 | /** |
| 771 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject <em>String Object</em>}'. | 666 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'. |
| 772 | * <!-- begin-user-doc --> | ||
| 773 | * This default implementation returns null so that we can easily ignore cases; | ||
| 774 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
| 775 | * <!-- end-user-doc --> | ||
| 776 | * @return the new adapter. | ||
| 777 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject | ||
| 778 | * @generated | ||
| 779 | */ | ||
| 780 | public Adapter createStringObjectAdapter() | ||
| 781 | { | ||
| 782 | return null; | ||
| 783 | } | ||
| 784 | |||
| 785 | /** | ||
| 786 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate <em>Predicate</em>}'. | ||
| 787 | * <!-- begin-user-doc --> | ||
| 788 | * This default implementation returns null so that we can easily ignore cases; | ||
| 789 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
| 790 | * <!-- end-user-doc --> | ||
| 791 | * @return the new adapter. | ||
| 792 | * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate | ||
| 793 | * @generated | ||
| 794 | */ | ||
| 795 | public Adapter createPredicateAdapter() | ||
| 796 | { | ||
| 797 | return null; | ||
| 798 | } | ||
| 799 | |||
| 800 | /** | ||
| 801 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter <em>Parameter</em>}'. | ||
| 802 | * <!-- begin-user-doc --> | ||
| 803 | * This default implementation returns null so that we can easily ignore cases; | ||
| 804 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | ||
| 805 | * <!-- end-user-doc --> | ||
| 806 | * @return the new adapter. | ||
| 807 | * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter | ||
| 808 | * @generated | ||
| 809 | */ | ||
| 810 | public Adapter createParameterAdapter() | ||
| 811 | { | ||
| 812 | return null; | ||
| 813 | } | ||
| 814 | |||
| 815 | /** | ||
| 816 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody <em>Pattern Body</em>}'. | ||
| 817 | * <!-- begin-user-doc --> | 667 | * <!-- begin-user-doc --> |
| 818 | * This default implementation returns null so that we can easily ignore cases; | 668 | * This default implementation returns null so that we can easily ignore cases; |
| 819 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 669 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 820 | * <!-- end-user-doc --> | 670 | * <!-- end-user-doc --> |
| 821 | * @return the new adapter. | 671 | * @return the new adapter. |
| 822 | * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody | 672 | * @see org.eclipse.viatra.solver.language.solverLanguage.Literal |
| 823 | * @generated | 673 | * @generated |
| 824 | */ | 674 | */ |
| 825 | public Adapter createPatternBodyAdapter() | 675 | public Adapter createLiteralAdapter() |
| 826 | { | 676 | { |
| 827 | return null; | 677 | return null; |
| 828 | } | 678 | } |
| 829 | 679 | ||
| 830 | /** | 680 | /** |
| 831 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity <em>Polarity</em>}'. | 681 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral <em>Logic Literal</em>}'. |
| 832 | * <!-- begin-user-doc --> | 682 | * <!-- begin-user-doc --> |
| 833 | * This default implementation returns null so that we can easily ignore cases; | 683 | * This default implementation returns null so that we can easily ignore cases; |
| 834 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 684 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 835 | * <!-- end-user-doc --> | 685 | * <!-- end-user-doc --> |
| 836 | * @return the new adapter. | 686 | * @return the new adapter. |
| 837 | * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity | 687 | * @see org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral |
| 838 | * @generated | 688 | * @generated |
| 839 | */ | 689 | */ |
| 840 | public Adapter createPolarityAdapter() | 690 | public Adapter createLogicLiteralAdapter() |
| 841 | { | 691 | { |
| 842 | return null; | 692 | return null; |
| 843 | } | 693 | } |
| 844 | 694 | ||
| 845 | /** | 695 | /** |
| 846 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint <em>Constraint</em>}'. | 696 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral <em>Numeric Literal</em>}'. |
| 847 | * <!-- begin-user-doc --> | 697 | * <!-- begin-user-doc --> |
| 848 | * This default implementation returns null so that we can easily ignore cases; | 698 | * This default implementation returns null so that we can easily ignore cases; |
| 849 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 699 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 850 | * <!-- end-user-doc --> | 700 | * <!-- end-user-doc --> |
| 851 | * @return the new adapter. | 701 | * @return the new adapter. |
| 852 | * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint | 702 | * @see org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral |
| 853 | * @generated | 703 | * @generated |
| 854 | */ | 704 | */ |
| 855 | public Adapter createConstraintAdapter() | 705 | public Adapter createNumericLiteralAdapter() |
| 856 | { | 706 | { |
| 857 | return null; | 707 | return null; |
| 858 | } | 708 | } |
| 859 | 709 | ||
| 860 | /** | 710 | /** |
| 861 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType <em>Closure Type</em>}'. | 711 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral <em>Infinity Literal</em>}'. |
| 862 | * <!-- begin-user-doc --> | 712 | * <!-- begin-user-doc --> |
| 863 | * This default implementation returns null so that we can easily ignore cases; | 713 | * This default implementation returns null so that we can easily ignore cases; |
| 864 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 714 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 865 | * <!-- end-user-doc --> | 715 | * <!-- end-user-doc --> |
| 866 | * @return the new adapter. | 716 | * @return the new adapter. |
| 867 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType | 717 | * @see org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral |
| 868 | * @generated | 718 | * @generated |
| 869 | */ | 719 | */ |
| 870 | public Adapter createClosureTypeAdapter() | 720 | public Adapter createInfinityLiteralAdapter() |
| 871 | { | 721 | { |
| 872 | return null; | 722 | return null; |
| 873 | } | 723 | } |
| 874 | 724 | ||
| 875 | /** | 725 | /** |
| 876 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'. | 726 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral <em>Empty Interval Literal</em>}'. |
| 877 | * <!-- begin-user-doc --> | 727 | * <!-- begin-user-doc --> |
| 878 | * This default implementation returns null so that we can easily ignore cases; | 728 | * This default implementation returns null so that we can easily ignore cases; |
| 879 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 729 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 880 | * <!-- end-user-doc --> | 730 | * <!-- end-user-doc --> |
| 881 | * @return the new adapter. | 731 | * @return the new adapter. |
| 882 | * @see org.eclipse.viatra.solver.language.solverLanguage.Literal | 732 | * @see org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral |
| 883 | * @generated | 733 | * @generated |
| 884 | */ | 734 | */ |
| 885 | public Adapter createLiteralAdapter() | 735 | public Adapter createEmptyIntervalLiteralAdapter() |
| 886 | { | 736 | { |
| 887 | return null; | 737 | return null; |
| 888 | } | 738 | } |
| 889 | 739 | ||
| 890 | /** | 740 | /** |
| 891 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable <em>Variable</em>}'. | 741 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringLiteral <em>String Literal</em>}'. |
| 892 | * <!-- begin-user-doc --> | 742 | * <!-- begin-user-doc --> |
| 893 | * This default implementation returns null so that we can easily ignore cases; | 743 | * This default implementation returns null so that we can easily ignore cases; |
| 894 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 744 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 895 | * <!-- end-user-doc --> | 745 | * <!-- end-user-doc --> |
| 896 | * @return the new adapter. | 746 | * @return the new adapter. |
| 897 | * @see org.eclipse.viatra.solver.language.solverLanguage.Variable | 747 | * @see org.eclipse.viatra.solver.language.solverLanguage.StringLiteral |
| 898 | * @generated | 748 | * @generated |
| 899 | */ | 749 | */ |
| 900 | public Adapter createVariableAdapter() | 750 | public Adapter createStringLiteralAdapter() |
| 901 | { | 751 | { |
| 902 | return null; | 752 | return null; |
| 903 | } | 753 | } |
| 904 | 754 | ||
| 905 | /** | 755 | /** |
| 906 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances <em>All Instances</em>}'. | 756 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition <em>Class Definition</em>}'. |
| 907 | * <!-- begin-user-doc --> | 757 | * <!-- begin-user-doc --> |
| 908 | * This default implementation returns null so that we can easily ignore cases; | 758 | * This default implementation returns null so that we can easily ignore cases; |
| 909 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 759 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 910 | * <!-- end-user-doc --> | 760 | * <!-- end-user-doc --> |
| 911 | * @return the new adapter. | 761 | * @return the new adapter. |
| 912 | * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances | 762 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition |
| 913 | * @generated | 763 | * @generated |
| 914 | */ | 764 | */ |
| 915 | public Adapter createAllInstancesAdapter() | 765 | public Adapter createClassDefinitionAdapter() |
| 916 | { | 766 | { |
| 917 | return null; | 767 | return null; |
| 918 | } | 768 | } |
| 919 | 769 | ||
| 920 | /** | 770 | /** |
| 921 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects <em>All Objects</em>}'. | 771 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition <em>Member Definition</em>}'. |
| 922 | * <!-- begin-user-doc --> | 772 | * <!-- begin-user-doc --> |
| 923 | * This default implementation returns null so that we can easily ignore cases; | 773 | * This default implementation returns null so that we can easily ignore cases; |
| 924 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 774 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 925 | * <!-- end-user-doc --> | 775 | * <!-- end-user-doc --> |
| 926 | * @return the new adapter. | 776 | * @return the new adapter. |
| 927 | * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects | 777 | * @see org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition |
| 928 | * @generated | 778 | * @generated |
| 929 | */ | 779 | */ |
| 930 | public Adapter createAllObjectsAdapter() | 780 | public Adapter createMemberDefinitionAdapter() |
| 931 | { | 781 | { |
| 932 | return null; | 782 | return null; |
| 933 | } | 783 | } |
| 934 | 784 | ||
| 935 | /** | 785 | /** |
| 936 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation <em>Default Interpretation</em>}'. | 786 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Multiplicity <em>Multiplicity</em>}'. |
| 937 | * <!-- begin-user-doc --> | 787 | * <!-- begin-user-doc --> |
| 938 | * This default implementation returns null so that we can easily ignore cases; | 788 | * This default implementation returns null so that we can easily ignore cases; |
| 939 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 789 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 940 | * <!-- end-user-doc --> | 790 | * <!-- end-user-doc --> |
| 941 | * @return the new adapter. | 791 | * @return the new adapter. |
| 942 | * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation | 792 | * @see org.eclipse.viatra.solver.language.solverLanguage.Multiplicity |
| 943 | * @generated | 793 | * @generated |
| 944 | */ | 794 | */ |
| 945 | public Adapter createDefaultInterpretationAdapter() | 795 | public Adapter createMultiplicityAdapter() |
| 946 | { | 796 | { |
| 947 | return null; | 797 | return null; |
| 948 | } | 798 | } |
| 949 | 799 | ||
| 950 | /** | 800 | /** |
| 951 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation <em>CD Interpretation</em>}'. | 801 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity <em>Many Multiplicity</em>}'. |
| 952 | * <!-- begin-user-doc --> | 802 | * <!-- begin-user-doc --> |
| 953 | * This default implementation returns null so that we can easily ignore cases; | 803 | * This default implementation returns null so that we can easily ignore cases; |
| 954 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 804 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 955 | * <!-- end-user-doc --> | 805 | * <!-- end-user-doc --> |
| 956 | * @return the new adapter. | 806 | * @return the new adapter. |
| 957 | * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation | 807 | * @see org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity |
| 958 | * @generated | 808 | * @generated |
| 959 | */ | 809 | */ |
| 960 | public Adapter createCDInterpretationAdapter() | 810 | public Adapter createManyMultiplicityAdapter() |
| 961 | { | 811 | { |
| 962 | return null; | 812 | return null; |
| 963 | } | 813 | } |
| 964 | 814 | ||
| 965 | /** | 815 | /** |
| 966 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation <em>Class Interpretation</em>}'. | 816 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity <em>Exact Multiplicity</em>}'. |
| 967 | * <!-- begin-user-doc --> | 817 | * <!-- begin-user-doc --> |
| 968 | * This default implementation returns null so that we can easily ignore cases; | 818 | * This default implementation returns null so that we can easily ignore cases; |
| 969 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 819 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 970 | * <!-- end-user-doc --> | 820 | * <!-- end-user-doc --> |
| 971 | * @return the new adapter. | 821 | * @return the new adapter. |
| 972 | * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation | 822 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity |
| 973 | * @generated | 823 | * @generated |
| 974 | */ | 824 | */ |
| 975 | public Adapter createClassInterpretationAdapter() | 825 | public Adapter createExactMultiplicityAdapter() |
| 976 | { | 826 | { |
| 977 | return null; | 827 | return null; |
| 978 | } | 828 | } |
| 979 | 829 | ||
| 980 | /** | 830 | /** |
| 981 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation <em>Enum Interpretation</em>}'. | 831 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity <em>Bounded Multiplicity</em>}'. |
| 982 | * <!-- begin-user-doc --> | 832 | * <!-- begin-user-doc --> |
| 983 | * This default implementation returns null so that we can easily ignore cases; | 833 | * This default implementation returns null so that we can easily ignore cases; |
| 984 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 834 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 985 | * <!-- end-user-doc --> | 835 | * <!-- end-user-doc --> |
| 986 | * @return the new adapter. | 836 | * @return the new adapter. |
| 987 | * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation | 837 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity |
| 988 | * @generated | 838 | * @generated |
| 989 | */ | 839 | */ |
| 990 | public Adapter createEnumInterpretationAdapter() | 840 | public Adapter createBoundedMultiplicityAdapter() |
| 991 | { | 841 | { |
| 992 | return null; | 842 | return null; |
| 993 | } | 843 | } |
| 994 | 844 | ||
| 995 | /** | 845 | /** |
| 996 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation <em>Field Relation Interpretation</em>}'. | 846 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition <em>Scope Definition</em>}'. |
| 997 | * <!-- begin-user-doc --> | 847 | * <!-- begin-user-doc --> |
| 998 | * This default implementation returns null so that we can easily ignore cases; | 848 | * This default implementation returns null so that we can easily ignore cases; |
| 999 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 849 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1000 | * <!-- end-user-doc --> | 850 | * <!-- end-user-doc --> |
| 1001 | * @return the new adapter. | 851 | * @return the new adapter. |
| 1002 | * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation | 852 | * @see org.eclipse.viatra.solver.language.solverLanguage.ScopeDefinition |
| 1003 | * @generated | 853 | * @generated |
| 1004 | */ | 854 | */ |
| 1005 | public Adapter createFieldRelationInterpretationAdapter() | 855 | public Adapter createScopeDefinitionAdapter() |
| 1006 | { | 856 | { |
| 1007 | return null; | 857 | return null; |
| 1008 | } | 858 | } |
| 1009 | 859 | ||
| 1010 | /** | 860 | /** |
| 1011 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation <em>Global Relation Interpretation</em>}'. | 861 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition <em>Exact Scope Definition</em>}'. |
| 1012 | * <!-- begin-user-doc --> | 862 | * <!-- begin-user-doc --> |
| 1013 | * This default implementation returns null so that we can easily ignore cases; | 863 | * This default implementation returns null so that we can easily ignore cases; |
| 1014 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 864 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1015 | * <!-- end-user-doc --> | 865 | * <!-- end-user-doc --> |
| 1016 | * @return the new adapter. | 866 | * @return the new adapter. |
| 1017 | * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation | 867 | * @see org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition |
| 1018 | * @generated | 868 | * @generated |
| 1019 | */ | 869 | */ |
| 1020 | public Adapter createGlobalRelationInterpretationAdapter() | 870 | public Adapter createExactScopeDefinitionAdapter() |
| 1021 | { | 871 | { |
| 1022 | return null; | 872 | return null; |
| 1023 | } | 873 | } |
| 1024 | 874 | ||
| 1025 | /** | 875 | /** |
| 1026 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition <em>Multiplicity Definition</em>}'. | 876 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition <em>Bounded Scope Definition</em>}'. |
| 1027 | * <!-- begin-user-doc --> | 877 | * <!-- begin-user-doc --> |
| 1028 | * This default implementation returns null so that we can easily ignore cases; | 878 | * This default implementation returns null so that we can easily ignore cases; |
| 1029 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 879 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1030 | * <!-- end-user-doc --> | 880 | * <!-- end-user-doc --> |
| 1031 | * @return the new adapter. | 881 | * @return the new adapter. |
| 1032 | * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition | 882 | * @see org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition |
| 1033 | * @generated | 883 | * @generated |
| 1034 | */ | 884 | */ |
| 1035 | public Adapter createMultiplicityDefinitionAdapter() | 885 | public Adapter createBoundedScopeDefinitionAdapter() |
| 1036 | { | 886 | { |
| 1037 | return null; | 887 | return null; |
| 1038 | } | 888 | } |
| 1039 | 889 | ||
| 1040 | /** | 890 | /** |
| 1041 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue <em>Boolean True</em>}'. | 891 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition <em>Lower Bounded Scope Definition</em>}'. |
| 1042 | * <!-- begin-user-doc --> | 892 | * <!-- begin-user-doc --> |
| 1043 | * This default implementation returns null so that we can easily ignore cases; | 893 | * This default implementation returns null so that we can easily ignore cases; |
| 1044 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 894 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1045 | * <!-- end-user-doc --> | 895 | * <!-- end-user-doc --> |
| 1046 | * @return the new adapter. | 896 | * @return the new adapter. |
| 1047 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue | 897 | * @see org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition |
| 1048 | * @generated | 898 | * @generated |
| 1049 | */ | 899 | */ |
| 1050 | public Adapter createBooleanTrueAdapter() | 900 | public Adapter createLowerBoundedScopeDefinitionAdapter() |
| 1051 | { | 901 | { |
| 1052 | return null; | 902 | return null; |
| 1053 | } | 903 | } |
| 1054 | 904 | ||
| 1055 | /** | 905 | /** |
| 1056 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse <em>Boolean False</em>}'. | 906 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition <em>Objective Definition</em>}'. |
| 1057 | * <!-- begin-user-doc --> | 907 | * <!-- begin-user-doc --> |
| 1058 | * This default implementation returns null so that we can easily ignore cases; | 908 | * This default implementation returns null so that we can easily ignore cases; |
| 1059 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 909 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1060 | * <!-- end-user-doc --> | 910 | * <!-- end-user-doc --> |
| 1061 | * @return the new adapter. | 911 | * @return the new adapter. |
| 1062 | * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse | 912 | * @see org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition |
| 1063 | * @generated | 913 | * @generated |
| 1064 | */ | 914 | */ |
| 1065 | public Adapter createBooleanFalseAdapter() | 915 | public Adapter createObjectiveDefinitionAdapter() |
| 1066 | { | 916 | { |
| 1067 | return null; | 917 | return null; |
| 1068 | } | 918 | } |
| 1069 | 919 | ||
| 1070 | /** | 920 | /** |
| 1071 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.True <em>True</em>}'. | 921 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedElement <em>Named Element</em>}'. |
| 1072 | * <!-- begin-user-doc --> | 922 | * <!-- begin-user-doc --> |
| 1073 | * This default implementation returns null so that we can easily ignore cases; | 923 | * This default implementation returns null so that we can easily ignore cases; |
| 1074 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 924 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1075 | * <!-- end-user-doc --> | 925 | * <!-- end-user-doc --> |
| 1076 | * @return the new adapter. | 926 | * @return the new adapter. |
| 1077 | * @see org.eclipse.viatra.solver.language.solverLanguage.True | 927 | * @see org.eclipse.viatra.solver.language.solverLanguage.NamedElement |
| 1078 | * @generated | 928 | * @generated |
| 1079 | */ | 929 | */ |
| 1080 | public Adapter createTrueAdapter() | 930 | public Adapter createNamedElementAdapter() |
| 1081 | { | 931 | { |
| 1082 | return null; | 932 | return null; |
| 1083 | } | 933 | } |
| 1084 | 934 | ||
| 1085 | /** | 935 | /** |
| 1086 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.False <em>False</em>}'. | 936 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Assertion <em>Assertion</em>}'. |
| 1087 | * <!-- begin-user-doc --> | 937 | * <!-- begin-user-doc --> |
| 1088 | * This default implementation returns null so that we can easily ignore cases; | 938 | * This default implementation returns null so that we can easily ignore cases; |
| 1089 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 939 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1090 | * <!-- end-user-doc --> | 940 | * <!-- end-user-doc --> |
| 1091 | * @return the new adapter. | 941 | * @return the new adapter. |
| 1092 | * @see org.eclipse.viatra.solver.language.solverLanguage.False | 942 | * @see org.eclipse.viatra.solver.language.solverLanguage.Assertion |
| 1093 | * @generated | 943 | * @generated |
| 1094 | */ | 944 | */ |
| 1095 | public Adapter createFalseAdapter() | 945 | public Adapter createAssertionAdapter() |
| 1096 | { | 946 | { |
| 1097 | return null; | 947 | return null; |
| 1098 | } | 948 | } |
| 1099 | 949 | ||
| 1100 | /** | 950 | /** |
| 1101 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown <em>Unknown</em>}'. | 951 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Disjunction <em>Disjunction</em>}'. |
| 1102 | * <!-- begin-user-doc --> | 952 | * <!-- begin-user-doc --> |
| 1103 | * This default implementation returns null so that we can easily ignore cases; | 953 | * This default implementation returns null so that we can easily ignore cases; |
| 1104 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 954 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1105 | * <!-- end-user-doc --> | 955 | * <!-- end-user-doc --> |
| 1106 | * @return the new adapter. | 956 | * @return the new adapter. |
| 1107 | * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown | 957 | * @see org.eclipse.viatra.solver.language.solverLanguage.Disjunction |
| 1108 | * @generated | 958 | * @generated |
| 1109 | */ | 959 | */ |
| 1110 | public Adapter createUnknownAdapter() | 960 | public Adapter createDisjunctionAdapter() |
| 1111 | { | 961 | { |
| 1112 | return null; | 962 | return null; |
| 1113 | } | 963 | } |
| 1114 | 964 | ||
| 1115 | /** | 965 | /** |
| 1116 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error <em>Error</em>}'. | 966 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Switch <em>Switch</em>}'. |
| 1117 | * <!-- begin-user-doc --> | 967 | * <!-- begin-user-doc --> |
| 1118 | * This default implementation returns null so that we can easily ignore cases; | 968 | * This default implementation returns null so that we can easily ignore cases; |
| 1119 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 969 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1120 | * <!-- end-user-doc --> | 970 | * <!-- end-user-doc --> |
| 1121 | * @return the new adapter. | 971 | * @return the new adapter. |
| 1122 | * @see org.eclipse.viatra.solver.language.solverLanguage.Error | 972 | * @see org.eclipse.viatra.solver.language.solverLanguage.Switch |
| 1123 | * @generated | 973 | * @generated |
| 1124 | */ | 974 | */ |
| 1125 | public Adapter createErrorAdapter() | 975 | public Adapter createSwitchAdapter() |
| 1126 | { | 976 | { |
| 1127 | return null; | 977 | return null; |
| 1128 | } | 978 | } |
| 1129 | 979 | ||
| 1130 | /** | 980 | /** |
| 1131 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive <em>Positive</em>}'. | 981 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Conjunction <em>Conjunction</em>}'. |
| 1132 | * <!-- begin-user-doc --> | 982 | * <!-- begin-user-doc --> |
| 1133 | * This default implementation returns null so that we can easily ignore cases; | 983 | * This default implementation returns null so that we can easily ignore cases; |
| 1134 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 984 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1135 | * <!-- end-user-doc --> | 985 | * <!-- end-user-doc --> |
| 1136 | * @return the new adapter. | 986 | * @return the new adapter. |
| 1137 | * @see org.eclipse.viatra.solver.language.solverLanguage.Positive | 987 | * @see org.eclipse.viatra.solver.language.solverLanguage.Conjunction |
| 1138 | * @generated | 988 | * @generated |
| 1139 | */ | 989 | */ |
| 1140 | public Adapter createPositiveAdapter() | 990 | public Adapter createConjunctionAdapter() |
| 1141 | { | 991 | { |
| 1142 | return null; | 992 | return null; |
| 1143 | } | 993 | } |
| 1144 | 994 | ||
| 1145 | /** | 995 | /** |
| 1146 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative <em>Negative</em>}'. | 996 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Comparison <em>Comparison</em>}'. |
| 1147 | * <!-- begin-user-doc --> | 997 | * <!-- begin-user-doc --> |
| 1148 | * This default implementation returns null so that we can easily ignore cases; | 998 | * This default implementation returns null so that we can easily ignore cases; |
| 1149 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 999 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1150 | * <!-- end-user-doc --> | 1000 | * <!-- end-user-doc --> |
| 1151 | * @return the new adapter. | 1001 | * @return the new adapter. |
| 1152 | * @see org.eclipse.viatra.solver.language.solverLanguage.Negative | 1002 | * @see org.eclipse.viatra.solver.language.solverLanguage.Comparison |
| 1153 | * @generated | 1003 | * @generated |
| 1154 | */ | 1004 | */ |
| 1155 | public Adapter createNegativeAdapter() | 1005 | public Adapter createComparisonAdapter() |
| 1156 | { | 1006 | { |
| 1157 | return null; | 1007 | return null; |
| 1158 | } | 1008 | } |
| 1159 | 1009 | ||
| 1160 | /** | 1010 | /** |
| 1161 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure <em>Reflexive Closure</em>}'. | 1011 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression <em>Binary Expression</em>}'. |
| 1162 | * <!-- begin-user-doc --> | 1012 | * <!-- begin-user-doc --> |
| 1163 | * This default implementation returns null so that we can easily ignore cases; | 1013 | * This default implementation returns null so that we can easily ignore cases; |
| 1164 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 1014 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1165 | * <!-- end-user-doc --> | 1015 | * <!-- end-user-doc --> |
| 1166 | * @return the new adapter. | 1016 | * @return the new adapter. |
| 1167 | * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure | 1017 | * @see org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression |
| 1168 | * @generated | 1018 | * @generated |
| 1169 | */ | 1019 | */ |
| 1170 | public Adapter createReflexiveClosureAdapter() | 1020 | public Adapter createBinaryExpressionAdapter() |
| 1171 | { | 1021 | { |
| 1172 | return null; | 1022 | return null; |
| 1173 | } | 1023 | } |
| 1174 | 1024 | ||
| 1175 | /** | 1025 | /** |
| 1176 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure <em>Irreflexive Closure</em>}'. | 1026 | * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression <em>Unary Expression</em>}'. |
| 1177 | * <!-- begin-user-doc --> | 1027 | * <!-- begin-user-doc --> |
| 1178 | * This default implementation returns null so that we can easily ignore cases; | 1028 | * This default implementation returns null so that we can easily ignore cases; |
| 1179 | * it's useful to ignore a case when inheritance will catch all the cases anyway. | 1029 | * it's useful to ignore a case when inheritance will catch all the cases anyway. |
| 1180 | * <!-- end-user-doc --> | 1030 | * <!-- end-user-doc --> |
| 1181 | * @return the new adapter. | 1031 | * @return the new adapter. |
| 1182 | * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure | 1032 | * @see org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression |
| 1183 | * @generated | 1033 | * @generated |
| 1184 | */ | 1034 | */ |
| 1185 | public Adapter createIrreflexiveClosureAdapter() | 1035 | public Adapter createUnaryExpressionAdapter() |
| 1186 | { | 1036 | { |
| 1187 | return null; | 1037 | return null; |
| 1188 | } | 1038 | } |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java index 6f6bcd17..79a98ff7 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /** | 1 | /** |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.solverLanguage.util; | 4 | package org.eclipse.viatra.solver.language.solverLanguage.util; |
| 5 | 5 | ||
| @@ -8,57 +8,7 @@ import org.eclipse.emf.ecore.EPackage; | |||
| 8 | 8 | ||
| 9 | import org.eclipse.emf.ecore.util.Switch; | 9 | import org.eclipse.emf.ecore.util.Switch; |
| 10 | 10 | ||
| 11 | import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; | 11 | import org.eclipse.viatra.solver.language.solverLanguage.*; |
| 12 | import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; | ||
| 13 | import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; | ||
| 14 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; | ||
| 15 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; | ||
| 16 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; | ||
| 17 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; | ||
| 18 | import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; | ||
| 19 | import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; | ||
| 20 | import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; | ||
| 21 | import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; | ||
| 22 | import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; | ||
| 23 | import org.eclipse.viatra.solver.language.solverLanguage.Constraint; | ||
| 24 | import org.eclipse.viatra.solver.language.solverLanguage.DataObject; | ||
| 25 | import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; | ||
| 26 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; | ||
| 27 | import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; | ||
| 28 | import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; | ||
| 29 | import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; | ||
| 30 | import org.eclipse.viatra.solver.language.solverLanguage.False; | ||
| 31 | import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; | ||
| 32 | import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; | ||
| 33 | import org.eclipse.viatra.solver.language.solverLanguage.IntObject; | ||
| 34 | import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; | ||
| 35 | import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; | ||
| 36 | import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; | ||
| 37 | import org.eclipse.viatra.solver.language.solverLanguage.Literal; | ||
| 38 | import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; | ||
| 39 | import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; | ||
| 40 | import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; | ||
| 41 | import org.eclipse.viatra.solver.language.solverLanguage.Negative; | ||
| 42 | import org.eclipse.viatra.solver.language.solverLanguage.Parameter; | ||
| 43 | import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; | ||
| 44 | import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; | ||
| 45 | import org.eclipse.viatra.solver.language.solverLanguage.Polarity; | ||
| 46 | import org.eclipse.viatra.solver.language.solverLanguage.Positive; | ||
| 47 | import org.eclipse.viatra.solver.language.solverLanguage.Predicate; | ||
| 48 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | ||
| 49 | import org.eclipse.viatra.solver.language.solverLanguage.RealObject; | ||
| 50 | import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; | ||
| 51 | import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; | ||
| 52 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
| 53 | import org.eclipse.viatra.solver.language.solverLanguage.Statement; | ||
| 54 | import org.eclipse.viatra.solver.language.solverLanguage.StringObject; | ||
| 55 | import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; | ||
| 56 | import org.eclipse.viatra.solver.language.solverLanguage.Symbol; | ||
| 57 | import org.eclipse.viatra.solver.language.solverLanguage.True; | ||
| 58 | import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; | ||
| 59 | import org.eclipse.viatra.solver.language.solverLanguage.Unknown; | ||
| 60 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; | ||
| 61 | import org.eclipse.viatra.solver.language.solverLanguage.Variable; | ||
| 62 | 12 | ||
| 63 | /** | 13 | /** |
| 64 | * <!-- begin-user-doc --> | 14 | * <!-- begin-user-doc --> |
| @@ -137,423 +87,385 @@ public class SolverLanguageSwitch<T> extends Switch<T> | |||
| 137 | if (result == null) result = defaultCase(theEObject); | 87 | if (result == null) result = defaultCase(theEObject); |
| 138 | return result; | 88 | return result; |
| 139 | } | 89 | } |
| 140 | case SolverLanguagePackage.BOOLEAN_VALUE: | 90 | case SolverLanguagePackage.PREDICATE_DEFINITION: |
| 141 | { | 91 | { |
| 142 | BooleanValue booleanValue = (BooleanValue)theEObject; | 92 | PredicateDefinition predicateDefinition = (PredicateDefinition)theEObject; |
| 143 | T result = caseBooleanValue(booleanValue); | 93 | T result = casePredicateDefinition(predicateDefinition); |
| 94 | if (result == null) result = caseStatement(predicateDefinition); | ||
| 144 | if (result == null) result = defaultCase(theEObject); | 95 | if (result == null) result = defaultCase(theEObject); |
| 145 | return result; | 96 | return result; |
| 146 | } | 97 | } |
| 147 | case SolverLanguagePackage.TRUTH_VALUE: | 98 | case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: |
| 148 | { | 99 | { |
| 149 | TruthValue truthValue = (TruthValue)theEObject; | 100 | UnnamedErrorPrediateDefinition unnamedErrorPrediateDefinition = (UnnamedErrorPrediateDefinition)theEObject; |
| 150 | T result = caseTruthValue(truthValue); | 101 | T result = caseUnnamedErrorPrediateDefinition(unnamedErrorPrediateDefinition); |
| 102 | if (result == null) result = caseStatement(unnamedErrorPrediateDefinition); | ||
| 151 | if (result == null) result = defaultCase(theEObject); | 103 | if (result == null) result = defaultCase(theEObject); |
| 152 | return result; | 104 | return result; |
| 153 | } | 105 | } |
| 154 | case SolverLanguagePackage.INTERPRETATION: | 106 | case SolverLanguagePackage.DEFAULT_DEFINITION: |
| 155 | { | 107 | { |
| 156 | Interpretation interpretation = (Interpretation)theEObject; | 108 | DefaultDefinition defaultDefinition = (DefaultDefinition)theEObject; |
| 157 | T result = caseInterpretation(interpretation); | 109 | T result = caseDefaultDefinition(defaultDefinition); |
| 158 | if (result == null) result = caseStatement(interpretation); | 110 | if (result == null) result = caseStatement(defaultDefinition); |
| 159 | if (result == null) result = defaultCase(theEObject); | 111 | if (result == null) result = defaultCase(theEObject); |
| 160 | return result; | 112 | return result; |
| 161 | } | 113 | } |
| 162 | case SolverLanguagePackage.BASIC_INTERPRETATION: | 114 | case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: |
| 163 | { | 115 | { |
| 164 | BasicInterpretation basicInterpretation = (BasicInterpretation)theEObject; | 116 | ExternPredicateDefinition externPredicateDefinition = (ExternPredicateDefinition)theEObject; |
| 165 | T result = caseBasicInterpretation(basicInterpretation); | 117 | T result = caseExternPredicateDefinition(externPredicateDefinition); |
| 166 | if (result == null) result = caseInterpretation(basicInterpretation); | 118 | if (result == null) result = caseStatement(externPredicateDefinition); |
| 167 | if (result == null) result = caseStatement(basicInterpretation); | ||
| 168 | if (result == null) result = defaultCase(theEObject); | 119 | if (result == null) result = defaultCase(theEObject); |
| 169 | return result; | 120 | return result; |
| 170 | } | 121 | } |
| 171 | case SolverLanguagePackage.SYMBOL: | 122 | case SolverLanguagePackage.METRIC_DEFINITION: |
| 172 | { | 123 | { |
| 173 | Symbol symbol = (Symbol)theEObject; | 124 | MetricDefinition metricDefinition = (MetricDefinition)theEObject; |
| 174 | T result = caseSymbol(symbol); | 125 | T result = caseMetricDefinition(metricDefinition); |
| 126 | if (result == null) result = caseStatement(metricDefinition); | ||
| 175 | if (result == null) result = defaultCase(theEObject); | 127 | if (result == null) result = defaultCase(theEObject); |
| 176 | return result; | 128 | return result; |
| 177 | } | 129 | } |
| 178 | case SolverLanguagePackage.MODEL_SYMBOL: | 130 | case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: |
| 179 | { | 131 | { |
| 180 | ModelSymbol modelSymbol = (ModelSymbol)theEObject; | 132 | ExternMetricDefinition externMetricDefinition = (ExternMetricDefinition)theEObject; |
| 181 | T result = caseModelSymbol(modelSymbol); | 133 | T result = caseExternMetricDefinition(externMetricDefinition); |
| 182 | if (result == null) result = caseSymbol(modelSymbol); | 134 | if (result == null) result = caseStatement(externMetricDefinition); |
| 183 | if (result == null) result = defaultCase(theEObject); | 135 | if (result == null) result = defaultCase(theEObject); |
| 184 | return result; | 136 | return result; |
| 185 | } | 137 | } |
| 186 | case SolverLanguagePackage.PARTIALITY_SYMBOL: | 138 | case SolverLanguagePackage.EXPRESSION: |
| 187 | { | 139 | { |
| 188 | PartialitySymbol partialitySymbol = (PartialitySymbol)theEObject; | 140 | Expression expression = (Expression)theEObject; |
| 189 | T result = casePartialitySymbol(partialitySymbol); | 141 | T result = caseExpression(expression); |
| 190 | if (result == null) result = caseSymbol(partialitySymbol); | 142 | if (result == null) result = caseStatement(expression); |
| 191 | if (result == null) result = defaultCase(theEObject); | 143 | if (result == null) result = defaultCase(theEObject); |
| 192 | return result; | 144 | return result; |
| 193 | } | 145 | } |
| 194 | case SolverLanguagePackage.EXIST_SYMBOL: | 146 | case SolverLanguagePackage.IF_ELSE: |
| 195 | { | 147 | { |
| 196 | ExistSymbol existSymbol = (ExistSymbol)theEObject; | 148 | IfElse ifElse = (IfElse)theEObject; |
| 197 | T result = caseExistSymbol(existSymbol); | 149 | T result = caseIfElse(ifElse); |
| 198 | if (result == null) result = casePartialitySymbol(existSymbol); | 150 | if (result == null) result = caseExpression(ifElse); |
| 199 | if (result == null) result = caseSymbol(existSymbol); | 151 | if (result == null) result = caseStatement(ifElse); |
| 200 | if (result == null) result = defaultCase(theEObject); | 152 | if (result == null) result = defaultCase(theEObject); |
| 201 | return result; | 153 | return result; |
| 202 | } | 154 | } |
| 203 | case SolverLanguagePackage.EQUALS_SYMBOL: | 155 | case SolverLanguagePackage.CASE: |
| 204 | { | 156 | { |
| 205 | EqualsSymbol equalsSymbol = (EqualsSymbol)theEObject; | 157 | Case case_ = (Case)theEObject; |
| 206 | T result = caseEqualsSymbol(equalsSymbol); | 158 | T result = caseCase(case_); |
| 207 | if (result == null) result = casePartialitySymbol(equalsSymbol); | 159 | if (result == null) result = caseExpression(case_); |
| 208 | if (result == null) result = caseSymbol(equalsSymbol); | 160 | if (result == null) result = caseStatement(case_); |
| 209 | if (result == null) result = defaultCase(theEObject); | 161 | if (result == null) result = defaultCase(theEObject); |
| 210 | return result; | 162 | return result; |
| 211 | } | 163 | } |
| 212 | case SolverLanguagePackage.DATA_SYMBOL: | 164 | case SolverLanguagePackage.COUNT: |
| 213 | { | 165 | { |
| 214 | DataSymbol dataSymbol = (DataSymbol)theEObject; | 166 | Count count = (Count)theEObject; |
| 215 | T result = caseDataSymbol(dataSymbol); | 167 | T result = caseCount(count); |
| 216 | if (result == null) result = caseSymbol(dataSymbol); | 168 | if (result == null) result = caseExpression(count); |
| 169 | if (result == null) result = caseStatement(count); | ||
| 217 | if (result == null) result = defaultCase(theEObject); | 170 | if (result == null) result = defaultCase(theEObject); |
| 218 | return result; | 171 | return result; |
| 219 | } | 172 | } |
| 220 | case SolverLanguagePackage.BOOLEAN_SYMBOL: | 173 | case SolverLanguagePackage.AGGREGATION: |
| 221 | { | 174 | { |
| 222 | BooleanSymbol booleanSymbol = (BooleanSymbol)theEObject; | 175 | Aggregation aggregation = (Aggregation)theEObject; |
| 223 | T result = caseBooleanSymbol(booleanSymbol); | 176 | T result = caseAggregation(aggregation); |
| 224 | if (result == null) result = caseDataSymbol(booleanSymbol); | 177 | if (result == null) result = caseExpression(aggregation); |
| 225 | if (result == null) result = caseSymbol(booleanSymbol); | 178 | if (result == null) result = caseStatement(aggregation); |
| 226 | if (result == null) result = defaultCase(theEObject); | 179 | if (result == null) result = defaultCase(theEObject); |
| 227 | return result; | 180 | return result; |
| 228 | } | 181 | } |
| 229 | case SolverLanguagePackage.INTEGER_SYMBOL: | 182 | case SolverLanguagePackage.CALL: |
| 230 | { | 183 | { |
| 231 | IntegerSymbol integerSymbol = (IntegerSymbol)theEObject; | 184 | Call call = (Call)theEObject; |
| 232 | T result = caseIntegerSymbol(integerSymbol); | 185 | T result = caseCall(call); |
| 233 | if (result == null) result = caseDataSymbol(integerSymbol); | 186 | if (result == null) result = caseExpression(call); |
| 234 | if (result == null) result = caseSymbol(integerSymbol); | 187 | if (result == null) result = caseStatement(call); |
| 235 | if (result == null) result = defaultCase(theEObject); | 188 | if (result == null) result = defaultCase(theEObject); |
| 236 | return result; | 189 | return result; |
| 237 | } | 190 | } |
| 238 | case SolverLanguagePackage.REAL_SYMBOL: | 191 | case SolverLanguagePackage.ARGUMENT_LIST: |
| 239 | { | 192 | { |
| 240 | RealSymbol realSymbol = (RealSymbol)theEObject; | 193 | ArgumentList argumentList = (ArgumentList)theEObject; |
| 241 | T result = caseRealSymbol(realSymbol); | 194 | T result = caseArgumentList(argumentList); |
| 242 | if (result == null) result = caseDataSymbol(realSymbol); | ||
| 243 | if (result == null) result = caseSymbol(realSymbol); | ||
| 244 | if (result == null) result = defaultCase(theEObject); | 195 | if (result == null) result = defaultCase(theEObject); |
| 245 | return result; | 196 | return result; |
| 246 | } | 197 | } |
| 247 | case SolverLanguagePackage.STRING_SYMBOL: | 198 | case SolverLanguagePackage.ARGUMENT: |
| 248 | { | 199 | { |
| 249 | StringSymbol stringSymbol = (StringSymbol)theEObject; | 200 | Argument argument = (Argument)theEObject; |
| 250 | T result = caseStringSymbol(stringSymbol); | 201 | T result = caseArgument(argument); |
| 251 | if (result == null) result = caseDataSymbol(stringSymbol); | ||
| 252 | if (result == null) result = caseSymbol(stringSymbol); | ||
| 253 | if (result == null) result = defaultCase(theEObject); | 202 | if (result == null) result = defaultCase(theEObject); |
| 254 | return result; | 203 | return result; |
| 255 | } | 204 | } |
| 256 | case SolverLanguagePackage.COMPLEX_OBJECT: | 205 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: |
| 257 | { | 206 | { |
| 258 | ComplexObject complexObject = (ComplexObject)theEObject; | 207 | ExpressionArgument expressionArgument = (ExpressionArgument)theEObject; |
| 259 | T result = caseComplexObject(complexObject); | 208 | T result = caseExpressionArgument(expressionArgument); |
| 209 | if (result == null) result = caseArgument(expressionArgument); | ||
| 260 | if (result == null) result = defaultCase(theEObject); | 210 | if (result == null) result = defaultCase(theEObject); |
| 261 | return result; | 211 | return result; |
| 262 | } | 212 | } |
| 263 | case SolverLanguagePackage.OBJECT: | 213 | case SolverLanguagePackage.STAR_ARGUMENT: |
| 264 | { | 214 | { |
| 265 | org.eclipse.viatra.solver.language.solverLanguage.Object object = (org.eclipse.viatra.solver.language.solverLanguage.Object)theEObject; | 215 | StarArgument starArgument = (StarArgument)theEObject; |
| 266 | T result = caseObject(object); | 216 | T result = caseStarArgument(starArgument); |
| 267 | if (result == null) result = caseComplexObject(object); | 217 | if (result == null) result = caseArgument(starArgument); |
| 268 | if (result == null) result = defaultCase(theEObject); | 218 | if (result == null) result = defaultCase(theEObject); |
| 269 | return result; | 219 | return result; |
| 270 | } | 220 | } |
| 271 | case SolverLanguagePackage.NAMED_OBJECT: | 221 | case SolverLanguagePackage.TYPED_ARGUMENT: |
| 272 | { | 222 | { |
| 273 | NamedObject namedObject = (NamedObject)theEObject; | 223 | TypedArgument typedArgument = (TypedArgument)theEObject; |
| 274 | T result = caseNamedObject(namedObject); | 224 | T result = caseTypedArgument(typedArgument); |
| 275 | if (result == null) result = caseObject(namedObject); | 225 | if (result == null) result = caseArgument(typedArgument); |
| 276 | if (result == null) result = caseLiteral(namedObject); | ||
| 277 | if (result == null) result = caseComplexObject(namedObject); | ||
| 278 | if (result == null) result = defaultCase(theEObject); | 226 | if (result == null) result = defaultCase(theEObject); |
| 279 | return result; | 227 | return result; |
| 280 | } | 228 | } |
| 281 | case SolverLanguagePackage.UNNAMED_OBJECT: | 229 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: |
| 282 | { | 230 | { |
| 283 | UnnamedObject unnamedObject = (UnnamedObject)theEObject; | 231 | TypedStarArgument typedStarArgument = (TypedStarArgument)theEObject; |
| 284 | T result = caseUnnamedObject(unnamedObject); | 232 | T result = caseTypedStarArgument(typedStarArgument); |
| 285 | if (result == null) result = caseObject(unnamedObject); | 233 | if (result == null) result = caseArgument(typedStarArgument); |
| 286 | if (result == null) result = caseComplexObject(unnamedObject); | ||
| 287 | if (result == null) result = defaultCase(theEObject); | 234 | if (result == null) result = defaultCase(theEObject); |
| 288 | return result; | 235 | return result; |
| 289 | } | 236 | } |
| 290 | case SolverLanguagePackage.DATA_OBJECT: | 237 | case SolverLanguagePackage.REFERENCE: |
| 291 | { | 238 | { |
| 292 | DataObject dataObject = (DataObject)theEObject; | 239 | Reference reference = (Reference)theEObject; |
| 293 | T result = caseDataObject(dataObject); | 240 | T result = caseReference(reference); |
| 294 | if (result == null) result = caseObject(dataObject); | 241 | if (result == null) result = caseExpression(reference); |
| 295 | if (result == null) result = caseLiteral(dataObject); | 242 | if (result == null) result = caseStatement(reference); |
| 296 | if (result == null) result = caseComplexObject(dataObject); | ||
| 297 | if (result == null) result = defaultCase(theEObject); | 243 | if (result == null) result = defaultCase(theEObject); |
| 298 | return result; | 244 | return result; |
| 299 | } | 245 | } |
| 300 | case SolverLanguagePackage.BOOLEAN_OBJECT: | 246 | case SolverLanguagePackage.INTERVAL: |
| 301 | { | 247 | { |
| 302 | BooleanObject booleanObject = (BooleanObject)theEObject; | 248 | Interval interval = (Interval)theEObject; |
| 303 | T result = caseBooleanObject(booleanObject); | 249 | T result = caseInterval(interval); |
| 304 | if (result == null) result = caseDataObject(booleanObject); | 250 | if (result == null) result = caseExpression(interval); |
| 305 | if (result == null) result = caseObject(booleanObject); | 251 | if (result == null) result = caseStatement(interval); |
| 306 | if (result == null) result = caseLiteral(booleanObject); | ||
| 307 | if (result == null) result = caseComplexObject(booleanObject); | ||
| 308 | if (result == null) result = defaultCase(theEObject); | 252 | if (result == null) result = defaultCase(theEObject); |
| 309 | return result; | 253 | return result; |
| 310 | } | 254 | } |
| 311 | case SolverLanguagePackage.INT_OBJECT: | 255 | case SolverLanguagePackage.LITERAL: |
| 312 | { | ||
| 313 | IntObject intObject = (IntObject)theEObject; | ||
| 314 | T result = caseIntObject(intObject); | ||
| 315 | if (result == null) result = caseDataObject(intObject); | ||
| 316 | if (result == null) result = caseObject(intObject); | ||
| 317 | if (result == null) result = caseLiteral(intObject); | ||
| 318 | if (result == null) result = caseComplexObject(intObject); | ||
| 319 | if (result == null) result = defaultCase(theEObject); | ||
| 320 | return result; | ||
| 321 | } | ||
| 322 | case SolverLanguagePackage.REAL_OBJECT: | ||
| 323 | { | ||
| 324 | RealObject realObject = (RealObject)theEObject; | ||
| 325 | T result = caseRealObject(realObject); | ||
| 326 | if (result == null) result = caseDataObject(realObject); | ||
| 327 | if (result == null) result = caseObject(realObject); | ||
| 328 | if (result == null) result = caseLiteral(realObject); | ||
| 329 | if (result == null) result = caseComplexObject(realObject); | ||
| 330 | if (result == null) result = defaultCase(theEObject); | ||
| 331 | return result; | ||
| 332 | } | ||
| 333 | case SolverLanguagePackage.STRING_OBJECT: | ||
| 334 | { | ||
| 335 | StringObject stringObject = (StringObject)theEObject; | ||
| 336 | T result = caseStringObject(stringObject); | ||
| 337 | if (result == null) result = caseDataObject(stringObject); | ||
| 338 | if (result == null) result = caseObject(stringObject); | ||
| 339 | if (result == null) result = caseLiteral(stringObject); | ||
| 340 | if (result == null) result = caseComplexObject(stringObject); | ||
| 341 | if (result == null) result = defaultCase(theEObject); | ||
| 342 | return result; | ||
| 343 | } | ||
| 344 | case SolverLanguagePackage.PREDICATE: | ||
| 345 | { | ||
| 346 | Predicate predicate = (Predicate)theEObject; | ||
| 347 | T result = casePredicate(predicate); | ||
| 348 | if (result == null) result = caseStatement(predicate); | ||
| 349 | if (result == null) result = defaultCase(theEObject); | ||
| 350 | return result; | ||
| 351 | } | ||
| 352 | case SolverLanguagePackage.PARAMETER: | ||
| 353 | { | 256 | { |
| 354 | Parameter parameter = (Parameter)theEObject; | 257 | Literal literal = (Literal)theEObject; |
| 355 | T result = caseParameter(parameter); | 258 | T result = caseLiteral(literal); |
| 259 | if (result == null) result = caseExpression(literal); | ||
| 260 | if (result == null) result = caseStatement(literal); | ||
| 356 | if (result == null) result = defaultCase(theEObject); | 261 | if (result == null) result = defaultCase(theEObject); |
| 357 | return result; | 262 | return result; |
| 358 | } | 263 | } |
| 359 | case SolverLanguagePackage.PATTERN_BODY: | 264 | case SolverLanguagePackage.LOGIC_LITERAL: |
| 360 | { | 265 | { |
| 361 | PatternBody patternBody = (PatternBody)theEObject; | 266 | LogicLiteral logicLiteral = (LogicLiteral)theEObject; |
| 362 | T result = casePatternBody(patternBody); | 267 | T result = caseLogicLiteral(logicLiteral); |
| 268 | if (result == null) result = caseLiteral(logicLiteral); | ||
| 269 | if (result == null) result = caseExpression(logicLiteral); | ||
| 270 | if (result == null) result = caseStatement(logicLiteral); | ||
| 363 | if (result == null) result = defaultCase(theEObject); | 271 | if (result == null) result = defaultCase(theEObject); |
| 364 | return result; | 272 | return result; |
| 365 | } | 273 | } |
| 366 | case SolverLanguagePackage.POLARITY: | 274 | case SolverLanguagePackage.NUMERIC_LITERAL: |
| 367 | { | 275 | { |
| 368 | Polarity polarity = (Polarity)theEObject; | 276 | NumericLiteral numericLiteral = (NumericLiteral)theEObject; |
| 369 | T result = casePolarity(polarity); | 277 | T result = caseNumericLiteral(numericLiteral); |
| 278 | if (result == null) result = caseLiteral(numericLiteral); | ||
| 279 | if (result == null) result = caseExpression(numericLiteral); | ||
| 280 | if (result == null) result = caseStatement(numericLiteral); | ||
| 370 | if (result == null) result = defaultCase(theEObject); | 281 | if (result == null) result = defaultCase(theEObject); |
| 371 | return result; | 282 | return result; |
| 372 | } | 283 | } |
| 373 | case SolverLanguagePackage.CONSTRAINT: | 284 | case SolverLanguagePackage.INFINITY_LITERAL: |
| 374 | { | 285 | { |
| 375 | Constraint constraint = (Constraint)theEObject; | 286 | InfinityLiteral infinityLiteral = (InfinityLiteral)theEObject; |
| 376 | T result = caseConstraint(constraint); | 287 | T result = caseInfinityLiteral(infinityLiteral); |
| 288 | if (result == null) result = caseLiteral(infinityLiteral); | ||
| 289 | if (result == null) result = caseExpression(infinityLiteral); | ||
| 290 | if (result == null) result = caseStatement(infinityLiteral); | ||
| 377 | if (result == null) result = defaultCase(theEObject); | 291 | if (result == null) result = defaultCase(theEObject); |
| 378 | return result; | 292 | return result; |
| 379 | } | 293 | } |
| 380 | case SolverLanguagePackage.CLOSURE_TYPE: | 294 | case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: |
| 381 | { | 295 | { |
| 382 | ClosureType closureType = (ClosureType)theEObject; | 296 | EmptyIntervalLiteral emptyIntervalLiteral = (EmptyIntervalLiteral)theEObject; |
| 383 | T result = caseClosureType(closureType); | 297 | T result = caseEmptyIntervalLiteral(emptyIntervalLiteral); |
| 298 | if (result == null) result = caseLiteral(emptyIntervalLiteral); | ||
| 299 | if (result == null) result = caseExpression(emptyIntervalLiteral); | ||
| 300 | if (result == null) result = caseStatement(emptyIntervalLiteral); | ||
| 384 | if (result == null) result = defaultCase(theEObject); | 301 | if (result == null) result = defaultCase(theEObject); |
| 385 | return result; | 302 | return result; |
| 386 | } | 303 | } |
| 387 | case SolverLanguagePackage.LITERAL: | 304 | case SolverLanguagePackage.STRING_LITERAL: |
| 388 | { | 305 | { |
| 389 | Literal literal = (Literal)theEObject; | 306 | StringLiteral stringLiteral = (StringLiteral)theEObject; |
| 390 | T result = caseLiteral(literal); | 307 | T result = caseStringLiteral(stringLiteral); |
| 308 | if (result == null) result = caseLiteral(stringLiteral); | ||
| 309 | if (result == null) result = caseExpression(stringLiteral); | ||
| 310 | if (result == null) result = caseStatement(stringLiteral); | ||
| 391 | if (result == null) result = defaultCase(theEObject); | 311 | if (result == null) result = defaultCase(theEObject); |
| 392 | return result; | 312 | return result; |
| 393 | } | 313 | } |
| 394 | case SolverLanguagePackage.VARIABLE: | 314 | case SolverLanguagePackage.CLASS_DEFINITION: |
| 395 | { | 315 | { |
| 396 | Variable variable = (Variable)theEObject; | 316 | ClassDefinition classDefinition = (ClassDefinition)theEObject; |
| 397 | T result = caseVariable(variable); | 317 | T result = caseClassDefinition(classDefinition); |
| 398 | if (result == null) result = caseLiteral(variable); | 318 | if (result == null) result = caseStatement(classDefinition); |
| 399 | if (result == null) result = defaultCase(theEObject); | 319 | if (result == null) result = defaultCase(theEObject); |
| 400 | return result; | 320 | return result; |
| 401 | } | 321 | } |
| 402 | case SolverLanguagePackage.ALL_INSTANCES: | 322 | case SolverLanguagePackage.MEMBER_DEFINITION: |
| 403 | { | 323 | { |
| 404 | AllInstances allInstances = (AllInstances)theEObject; | 324 | MemberDefinition memberDefinition = (MemberDefinition)theEObject; |
| 405 | T result = caseAllInstances(allInstances); | 325 | T result = caseMemberDefinition(memberDefinition); |
| 406 | if (result == null) result = caseComplexObject(allInstances); | ||
| 407 | if (result == null) result = defaultCase(theEObject); | 326 | if (result == null) result = defaultCase(theEObject); |
| 408 | return result; | 327 | return result; |
| 409 | } | 328 | } |
| 410 | case SolverLanguagePackage.ALL_OBJECTS: | 329 | case SolverLanguagePackage.MULTIPLICITY: |
| 411 | { | 330 | { |
| 412 | AllObjects allObjects = (AllObjects)theEObject; | 331 | Multiplicity multiplicity = (Multiplicity)theEObject; |
| 413 | T result = caseAllObjects(allObjects); | 332 | T result = caseMultiplicity(multiplicity); |
| 414 | if (result == null) result = caseComplexObject(allObjects); | ||
| 415 | if (result == null) result = defaultCase(theEObject); | 333 | if (result == null) result = defaultCase(theEObject); |
| 416 | return result; | 334 | return result; |
| 417 | } | 335 | } |
| 418 | case SolverLanguagePackage.DEFAULT_INTERPRETATION: | 336 | case SolverLanguagePackage.MANY_MULTIPLICITY: |
| 419 | { | 337 | { |
| 420 | DefaultInterpretation defaultInterpretation = (DefaultInterpretation)theEObject; | 338 | ManyMultiplicity manyMultiplicity = (ManyMultiplicity)theEObject; |
| 421 | T result = caseDefaultInterpretation(defaultInterpretation); | 339 | T result = caseManyMultiplicity(manyMultiplicity); |
| 422 | if (result == null) result = caseInterpretation(defaultInterpretation); | 340 | if (result == null) result = caseMultiplicity(manyMultiplicity); |
| 423 | if (result == null) result = caseStatement(defaultInterpretation); | ||
| 424 | if (result == null) result = defaultCase(theEObject); | 341 | if (result == null) result = defaultCase(theEObject); |
| 425 | return result; | 342 | return result; |
| 426 | } | 343 | } |
| 427 | case SolverLanguagePackage.CD_INTERPRETATION: | 344 | case SolverLanguagePackage.EXACT_MULTIPLICITY: |
| 428 | { | 345 | { |
| 429 | CDInterpretation cdInterpretation = (CDInterpretation)theEObject; | 346 | ExactMultiplicity exactMultiplicity = (ExactMultiplicity)theEObject; |
| 430 | T result = caseCDInterpretation(cdInterpretation); | 347 | T result = caseExactMultiplicity(exactMultiplicity); |
| 431 | if (result == null) result = caseInterpretation(cdInterpretation); | 348 | if (result == null) result = caseMultiplicity(exactMultiplicity); |
| 432 | if (result == null) result = caseStatement(cdInterpretation); | ||
| 433 | if (result == null) result = defaultCase(theEObject); | 349 | if (result == null) result = defaultCase(theEObject); |
| 434 | return result; | 350 | return result; |
| 435 | } | 351 | } |
| 436 | case SolverLanguagePackage.CLASS_INTERPRETATION: | 352 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: |
| 437 | { | 353 | { |
| 438 | ClassInterpretation classInterpretation = (ClassInterpretation)theEObject; | 354 | BoundedMultiplicity boundedMultiplicity = (BoundedMultiplicity)theEObject; |
| 439 | T result = caseClassInterpretation(classInterpretation); | 355 | T result = caseBoundedMultiplicity(boundedMultiplicity); |
| 440 | if (result == null) result = caseCDInterpretation(classInterpretation); | 356 | if (result == null) result = caseMultiplicity(boundedMultiplicity); |
| 441 | if (result == null) result = caseInterpretation(classInterpretation); | ||
| 442 | if (result == null) result = caseStatement(classInterpretation); | ||
| 443 | if (result == null) result = defaultCase(theEObject); | 357 | if (result == null) result = defaultCase(theEObject); |
| 444 | return result; | 358 | return result; |
| 445 | } | 359 | } |
| 446 | case SolverLanguagePackage.ENUM_INTERPRETATION: | 360 | case SolverLanguagePackage.SCOPE_DEFINITION: |
| 447 | { | 361 | { |
| 448 | EnumInterpretation enumInterpretation = (EnumInterpretation)theEObject; | 362 | ScopeDefinition scopeDefinition = (ScopeDefinition)theEObject; |
| 449 | T result = caseEnumInterpretation(enumInterpretation); | 363 | T result = caseScopeDefinition(scopeDefinition); |
| 450 | if (result == null) result = caseCDInterpretation(enumInterpretation); | 364 | if (result == null) result = caseStatement(scopeDefinition); |
| 451 | if (result == null) result = caseInterpretation(enumInterpretation); | ||
| 452 | if (result == null) result = caseStatement(enumInterpretation); | ||
| 453 | if (result == null) result = defaultCase(theEObject); | 365 | if (result == null) result = defaultCase(theEObject); |
| 454 | return result; | 366 | return result; |
| 455 | } | 367 | } |
| 456 | case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: | 368 | case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: |
| 457 | { | 369 | { |
| 458 | FieldRelationInterpretation fieldRelationInterpretation = (FieldRelationInterpretation)theEObject; | 370 | ExactScopeDefinition exactScopeDefinition = (ExactScopeDefinition)theEObject; |
| 459 | T result = caseFieldRelationInterpretation(fieldRelationInterpretation); | 371 | T result = caseExactScopeDefinition(exactScopeDefinition); |
| 372 | if (result == null) result = caseScopeDefinition(exactScopeDefinition); | ||
| 373 | if (result == null) result = caseStatement(exactScopeDefinition); | ||
| 460 | if (result == null) result = defaultCase(theEObject); | 374 | if (result == null) result = defaultCase(theEObject); |
| 461 | return result; | 375 | return result; |
| 462 | } | 376 | } |
| 463 | case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: | 377 | case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: |
| 464 | { | 378 | { |
| 465 | GlobalRelationInterpretation globalRelationInterpretation = (GlobalRelationInterpretation)theEObject; | 379 | BoundedScopeDefinition boundedScopeDefinition = (BoundedScopeDefinition)theEObject; |
| 466 | T result = caseGlobalRelationInterpretation(globalRelationInterpretation); | 380 | T result = caseBoundedScopeDefinition(boundedScopeDefinition); |
| 467 | if (result == null) result = caseCDInterpretation(globalRelationInterpretation); | 381 | if (result == null) result = caseScopeDefinition(boundedScopeDefinition); |
| 468 | if (result == null) result = caseInterpretation(globalRelationInterpretation); | 382 | if (result == null) result = caseStatement(boundedScopeDefinition); |
| 469 | if (result == null) result = caseStatement(globalRelationInterpretation); | ||
| 470 | if (result == null) result = defaultCase(theEObject); | 383 | if (result == null) result = defaultCase(theEObject); |
| 471 | return result; | 384 | return result; |
| 472 | } | 385 | } |
| 473 | case SolverLanguagePackage.MULTIPLICITY_DEFINITION: | 386 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: |
| 474 | { | 387 | { |
| 475 | MultiplicityDefinition multiplicityDefinition = (MultiplicityDefinition)theEObject; | 388 | LowerBoundedScopeDefinition lowerBoundedScopeDefinition = (LowerBoundedScopeDefinition)theEObject; |
| 476 | T result = caseMultiplicityDefinition(multiplicityDefinition); | 389 | T result = caseLowerBoundedScopeDefinition(lowerBoundedScopeDefinition); |
| 390 | if (result == null) result = caseScopeDefinition(lowerBoundedScopeDefinition); | ||
| 391 | if (result == null) result = caseStatement(lowerBoundedScopeDefinition); | ||
| 477 | if (result == null) result = defaultCase(theEObject); | 392 | if (result == null) result = defaultCase(theEObject); |
| 478 | return result; | 393 | return result; |
| 479 | } | 394 | } |
| 480 | case SolverLanguagePackage.BOOLEAN_TRUE: | 395 | case SolverLanguagePackage.OBJECTIVE_DEFINITION: |
| 481 | { | 396 | { |
| 482 | BooleanTrue booleanTrue = (BooleanTrue)theEObject; | 397 | ObjectiveDefinition objectiveDefinition = (ObjectiveDefinition)theEObject; |
| 483 | T result = caseBooleanTrue(booleanTrue); | 398 | T result = caseObjectiveDefinition(objectiveDefinition); |
| 484 | if (result == null) result = caseBooleanValue(booleanTrue); | 399 | if (result == null) result = caseStatement(objectiveDefinition); |
| 485 | if (result == null) result = defaultCase(theEObject); | 400 | if (result == null) result = defaultCase(theEObject); |
| 486 | return result; | 401 | return result; |
| 487 | } | 402 | } |
| 488 | case SolverLanguagePackage.BOOLEAN_FALSE: | 403 | case SolverLanguagePackage.NAMED_ELEMENT: |
| 489 | { | 404 | { |
| 490 | BooleanFalse booleanFalse = (BooleanFalse)theEObject; | 405 | NamedElement namedElement = (NamedElement)theEObject; |
| 491 | T result = caseBooleanFalse(booleanFalse); | 406 | T result = caseNamedElement(namedElement); |
| 492 | if (result == null) result = caseBooleanValue(booleanFalse); | ||
| 493 | if (result == null) result = defaultCase(theEObject); | 407 | if (result == null) result = defaultCase(theEObject); |
| 494 | return result; | 408 | return result; |
| 495 | } | 409 | } |
| 496 | case SolverLanguagePackage.TRUE: | 410 | case SolverLanguagePackage.ASSERTION: |
| 497 | { | 411 | { |
| 498 | True true_ = (True)theEObject; | 412 | Assertion assertion = (Assertion)theEObject; |
| 499 | T result = caseTrue(true_); | 413 | T result = caseAssertion(assertion); |
| 500 | if (result == null) result = caseTruthValue(true_); | 414 | if (result == null) result = caseStatement(assertion); |
| 501 | if (result == null) result = defaultCase(theEObject); | 415 | if (result == null) result = defaultCase(theEObject); |
| 502 | return result; | 416 | return result; |
| 503 | } | 417 | } |
| 504 | case SolverLanguagePackage.FALSE: | 418 | case SolverLanguagePackage.DISJUNCTION: |
| 505 | { | 419 | { |
| 506 | False false_ = (False)theEObject; | 420 | Disjunction disjunction = (Disjunction)theEObject; |
| 507 | T result = caseFalse(false_); | 421 | T result = caseDisjunction(disjunction); |
| 508 | if (result == null) result = caseTruthValue(false_); | 422 | if (result == null) result = caseExpression(disjunction); |
| 423 | if (result == null) result = caseStatement(disjunction); | ||
| 509 | if (result == null) result = defaultCase(theEObject); | 424 | if (result == null) result = defaultCase(theEObject); |
| 510 | return result; | 425 | return result; |
| 511 | } | 426 | } |
| 512 | case SolverLanguagePackage.UNKNOWN: | 427 | case SolverLanguagePackage.SWITCH: |
| 513 | { | 428 | { |
| 514 | Unknown unknown = (Unknown)theEObject; | 429 | org.eclipse.viatra.solver.language.solverLanguage.Switch switch_ = (org.eclipse.viatra.solver.language.solverLanguage.Switch)theEObject; |
| 515 | T result = caseUnknown(unknown); | 430 | T result = caseSwitch(switch_); |
| 516 | if (result == null) result = caseTruthValue(unknown); | 431 | if (result == null) result = caseExpression(switch_); |
| 432 | if (result == null) result = caseStatement(switch_); | ||
| 517 | if (result == null) result = defaultCase(theEObject); | 433 | if (result == null) result = defaultCase(theEObject); |
| 518 | return result; | 434 | return result; |
| 519 | } | 435 | } |
| 520 | case SolverLanguagePackage.ERROR: | 436 | case SolverLanguagePackage.CONJUNCTION: |
| 521 | { | 437 | { |
| 522 | org.eclipse.viatra.solver.language.solverLanguage.Error error = (org.eclipse.viatra.solver.language.solverLanguage.Error)theEObject; | 438 | Conjunction conjunction = (Conjunction)theEObject; |
| 523 | T result = caseError(error); | 439 | T result = caseConjunction(conjunction); |
| 524 | if (result == null) result = caseTruthValue(error); | 440 | if (result == null) result = caseExpression(conjunction); |
| 441 | if (result == null) result = caseStatement(conjunction); | ||
| 525 | if (result == null) result = defaultCase(theEObject); | 442 | if (result == null) result = defaultCase(theEObject); |
| 526 | return result; | 443 | return result; |
| 527 | } | 444 | } |
| 528 | case SolverLanguagePackage.POSITIVE: | 445 | case SolverLanguagePackage.COMPARISON: |
| 529 | { | 446 | { |
| 530 | Positive positive = (Positive)theEObject; | 447 | Comparison comparison = (Comparison)theEObject; |
| 531 | T result = casePositive(positive); | 448 | T result = caseComparison(comparison); |
| 532 | if (result == null) result = casePolarity(positive); | 449 | if (result == null) result = caseExpression(comparison); |
| 450 | if (result == null) result = caseStatement(comparison); | ||
| 533 | if (result == null) result = defaultCase(theEObject); | 451 | if (result == null) result = defaultCase(theEObject); |
| 534 | return result; | 452 | return result; |
| 535 | } | 453 | } |
| 536 | case SolverLanguagePackage.NEGATIVE: | 454 | case SolverLanguagePackage.BINARY_EXPRESSION: |
| 537 | { | 455 | { |
| 538 | Negative negative = (Negative)theEObject; | 456 | BinaryExpression binaryExpression = (BinaryExpression)theEObject; |
| 539 | T result = caseNegative(negative); | 457 | T result = caseBinaryExpression(binaryExpression); |
| 540 | if (result == null) result = casePolarity(negative); | 458 | if (result == null) result = caseExpression(binaryExpression); |
| 459 | if (result == null) result = caseStatement(binaryExpression); | ||
| 541 | if (result == null) result = defaultCase(theEObject); | 460 | if (result == null) result = defaultCase(theEObject); |
| 542 | return result; | 461 | return result; |
| 543 | } | 462 | } |
| 544 | case SolverLanguagePackage.REFLEXIVE_CLOSURE: | 463 | case SolverLanguagePackage.UNARY_EXPRESSION: |
| 545 | { | 464 | { |
| 546 | ReflexiveClosure reflexiveClosure = (ReflexiveClosure)theEObject; | 465 | UnaryExpression unaryExpression = (UnaryExpression)theEObject; |
| 547 | T result = caseReflexiveClosure(reflexiveClosure); | 466 | T result = caseUnaryExpression(unaryExpression); |
| 548 | if (result == null) result = caseClosureType(reflexiveClosure); | 467 | if (result == null) result = caseExpression(unaryExpression); |
| 549 | if (result == null) result = defaultCase(theEObject); | 468 | if (result == null) result = caseStatement(unaryExpression); |
| 550 | return result; | ||
| 551 | } | ||
| 552 | case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: | ||
| 553 | { | ||
| 554 | IrreflexiveClosure irreflexiveClosure = (IrreflexiveClosure)theEObject; | ||
| 555 | T result = caseIrreflexiveClosure(irreflexiveClosure); | ||
| 556 | if (result == null) result = caseClosureType(irreflexiveClosure); | ||
| 557 | if (result == null) result = defaultCase(theEObject); | 469 | if (result == null) result = defaultCase(theEObject); |
| 558 | return result; | 470 | return result; |
| 559 | } | 471 | } |
| @@ -594,801 +506,721 @@ public class SolverLanguageSwitch<T> extends Switch<T> | |||
| 594 | } | 506 | } |
| 595 | 507 | ||
| 596 | /** | 508 | /** |
| 597 | * Returns the result of interpreting the object as an instance of '<em>Boolean Value</em>'. | 509 | * Returns the result of interpreting the object as an instance of '<em>Predicate Definition</em>'. |
| 598 | * <!-- begin-user-doc --> | ||
| 599 | * This implementation returns null; | ||
| 600 | * returning a non-null result will terminate the switch. | ||
| 601 | * <!-- end-user-doc --> | ||
| 602 | * @param object the target of the switch. | ||
| 603 | * @return the result of interpreting the object as an instance of '<em>Boolean Value</em>'. | ||
| 604 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
| 605 | * @generated | ||
| 606 | */ | ||
| 607 | public T caseBooleanValue(BooleanValue object) | ||
| 608 | { | ||
| 609 | return null; | ||
| 610 | } | ||
| 611 | |||
| 612 | /** | ||
| 613 | * Returns the result of interpreting the object as an instance of '<em>Truth Value</em>'. | ||
| 614 | * <!-- begin-user-doc --> | 510 | * <!-- begin-user-doc --> |
| 615 | * This implementation returns null; | 511 | * This implementation returns null; |
| 616 | * returning a non-null result will terminate the switch. | 512 | * returning a non-null result will terminate the switch. |
| 617 | * <!-- end-user-doc --> | 513 | * <!-- end-user-doc --> |
| 618 | * @param object the target of the switch. | 514 | * @param object the target of the switch. |
| 619 | * @return the result of interpreting the object as an instance of '<em>Truth Value</em>'. | 515 | * @return the result of interpreting the object as an instance of '<em>Predicate Definition</em>'. |
| 620 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 516 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 621 | * @generated | 517 | * @generated |
| 622 | */ | 518 | */ |
| 623 | public T caseTruthValue(TruthValue object) | 519 | public T casePredicateDefinition(PredicateDefinition object) |
| 624 | { | 520 | { |
| 625 | return null; | 521 | return null; |
| 626 | } | 522 | } |
| 627 | 523 | ||
| 628 | /** | 524 | /** |
| 629 | * Returns the result of interpreting the object as an instance of '<em>Interpretation</em>'. | 525 | * Returns the result of interpreting the object as an instance of '<em>Unnamed Error Prediate Definition</em>'. |
| 630 | * <!-- begin-user-doc --> | 526 | * <!-- begin-user-doc --> |
| 631 | * This implementation returns null; | 527 | * This implementation returns null; |
| 632 | * returning a non-null result will terminate the switch. | 528 | * returning a non-null result will terminate the switch. |
| 633 | * <!-- end-user-doc --> | 529 | * <!-- end-user-doc --> |
| 634 | * @param object the target of the switch. | 530 | * @param object the target of the switch. |
| 635 | * @return the result of interpreting the object as an instance of '<em>Interpretation</em>'. | 531 | * @return the result of interpreting the object as an instance of '<em>Unnamed Error Prediate Definition</em>'. |
| 636 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 532 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 637 | * @generated | 533 | * @generated |
| 638 | */ | 534 | */ |
| 639 | public T caseInterpretation(Interpretation object) | 535 | public T caseUnnamedErrorPrediateDefinition(UnnamedErrorPrediateDefinition object) |
| 640 | { | 536 | { |
| 641 | return null; | 537 | return null; |
| 642 | } | 538 | } |
| 643 | 539 | ||
| 644 | /** | 540 | /** |
| 645 | * Returns the result of interpreting the object as an instance of '<em>Basic Interpretation</em>'. | 541 | * Returns the result of interpreting the object as an instance of '<em>Default Definition</em>'. |
| 646 | * <!-- begin-user-doc --> | 542 | * <!-- begin-user-doc --> |
| 647 | * This implementation returns null; | 543 | * This implementation returns null; |
| 648 | * returning a non-null result will terminate the switch. | 544 | * returning a non-null result will terminate the switch. |
| 649 | * <!-- end-user-doc --> | 545 | * <!-- end-user-doc --> |
| 650 | * @param object the target of the switch. | 546 | * @param object the target of the switch. |
| 651 | * @return the result of interpreting the object as an instance of '<em>Basic Interpretation</em>'. | 547 | * @return the result of interpreting the object as an instance of '<em>Default Definition</em>'. |
| 652 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 548 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 653 | * @generated | 549 | * @generated |
| 654 | */ | 550 | */ |
| 655 | public T caseBasicInterpretation(BasicInterpretation object) | 551 | public T caseDefaultDefinition(DefaultDefinition object) |
| 656 | { | 552 | { |
| 657 | return null; | 553 | return null; |
| 658 | } | 554 | } |
| 659 | 555 | ||
| 660 | /** | 556 | /** |
| 661 | * Returns the result of interpreting the object as an instance of '<em>Symbol</em>'. | 557 | * Returns the result of interpreting the object as an instance of '<em>Extern Predicate Definition</em>'. |
| 662 | * <!-- begin-user-doc --> | 558 | * <!-- begin-user-doc --> |
| 663 | * This implementation returns null; | 559 | * This implementation returns null; |
| 664 | * returning a non-null result will terminate the switch. | 560 | * returning a non-null result will terminate the switch. |
| 665 | * <!-- end-user-doc --> | 561 | * <!-- end-user-doc --> |
| 666 | * @param object the target of the switch. | 562 | * @param object the target of the switch. |
| 667 | * @return the result of interpreting the object as an instance of '<em>Symbol</em>'. | 563 | * @return the result of interpreting the object as an instance of '<em>Extern Predicate Definition</em>'. |
| 668 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 564 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 669 | * @generated | 565 | * @generated |
| 670 | */ | 566 | */ |
| 671 | public T caseSymbol(Symbol object) | 567 | public T caseExternPredicateDefinition(ExternPredicateDefinition object) |
| 672 | { | 568 | { |
| 673 | return null; | 569 | return null; |
| 674 | } | 570 | } |
| 675 | 571 | ||
| 676 | /** | 572 | /** |
| 677 | * Returns the result of interpreting the object as an instance of '<em>Model Symbol</em>'. | 573 | * Returns the result of interpreting the object as an instance of '<em>Metric Definition</em>'. |
| 678 | * <!-- begin-user-doc --> | 574 | * <!-- begin-user-doc --> |
| 679 | * This implementation returns null; | 575 | * This implementation returns null; |
| 680 | * returning a non-null result will terminate the switch. | 576 | * returning a non-null result will terminate the switch. |
| 681 | * <!-- end-user-doc --> | 577 | * <!-- end-user-doc --> |
| 682 | * @param object the target of the switch. | 578 | * @param object the target of the switch. |
| 683 | * @return the result of interpreting the object as an instance of '<em>Model Symbol</em>'. | 579 | * @return the result of interpreting the object as an instance of '<em>Metric Definition</em>'. |
| 684 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 580 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 685 | * @generated | 581 | * @generated |
| 686 | */ | 582 | */ |
| 687 | public T caseModelSymbol(ModelSymbol object) | 583 | public T caseMetricDefinition(MetricDefinition object) |
| 688 | { | 584 | { |
| 689 | return null; | 585 | return null; |
| 690 | } | 586 | } |
| 691 | 587 | ||
| 692 | /** | 588 | /** |
| 693 | * Returns the result of interpreting the object as an instance of '<em>Partiality Symbol</em>'. | 589 | * Returns the result of interpreting the object as an instance of '<em>Extern Metric Definition</em>'. |
| 694 | * <!-- begin-user-doc --> | 590 | * <!-- begin-user-doc --> |
| 695 | * This implementation returns null; | 591 | * This implementation returns null; |
| 696 | * returning a non-null result will terminate the switch. | 592 | * returning a non-null result will terminate the switch. |
| 697 | * <!-- end-user-doc --> | 593 | * <!-- end-user-doc --> |
| 698 | * @param object the target of the switch. | 594 | * @param object the target of the switch. |
| 699 | * @return the result of interpreting the object as an instance of '<em>Partiality Symbol</em>'. | 595 | * @return the result of interpreting the object as an instance of '<em>Extern Metric Definition</em>'. |
| 700 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 596 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 701 | * @generated | 597 | * @generated |
| 702 | */ | 598 | */ |
| 703 | public T casePartialitySymbol(PartialitySymbol object) | 599 | public T caseExternMetricDefinition(ExternMetricDefinition object) |
| 704 | { | 600 | { |
| 705 | return null; | 601 | return null; |
| 706 | } | 602 | } |
| 707 | 603 | ||
| 708 | /** | 604 | /** |
| 709 | * Returns the result of interpreting the object as an instance of '<em>Exist Symbol</em>'. | 605 | * Returns the result of interpreting the object as an instance of '<em>Expression</em>'. |
| 710 | * <!-- begin-user-doc --> | 606 | * <!-- begin-user-doc --> |
| 711 | * This implementation returns null; | 607 | * This implementation returns null; |
| 712 | * returning a non-null result will terminate the switch. | 608 | * returning a non-null result will terminate the switch. |
| 713 | * <!-- end-user-doc --> | 609 | * <!-- end-user-doc --> |
| 714 | * @param object the target of the switch. | 610 | * @param object the target of the switch. |
| 715 | * @return the result of interpreting the object as an instance of '<em>Exist Symbol</em>'. | 611 | * @return the result of interpreting the object as an instance of '<em>Expression</em>'. |
| 716 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 612 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 717 | * @generated | 613 | * @generated |
| 718 | */ | 614 | */ |
| 719 | public T caseExistSymbol(ExistSymbol object) | 615 | public T caseExpression(Expression object) |
| 720 | { | 616 | { |
| 721 | return null; | 617 | return null; |
| 722 | } | 618 | } |
| 723 | 619 | ||
| 724 | /** | 620 | /** |
| 725 | * Returns the result of interpreting the object as an instance of '<em>Equals Symbol</em>'. | 621 | * Returns the result of interpreting the object as an instance of '<em>If Else</em>'. |
| 726 | * <!-- begin-user-doc --> | 622 | * <!-- begin-user-doc --> |
| 727 | * This implementation returns null; | 623 | * This implementation returns null; |
| 728 | * returning a non-null result will terminate the switch. | 624 | * returning a non-null result will terminate the switch. |
| 729 | * <!-- end-user-doc --> | 625 | * <!-- end-user-doc --> |
| 730 | * @param object the target of the switch. | 626 | * @param object the target of the switch. |
| 731 | * @return the result of interpreting the object as an instance of '<em>Equals Symbol</em>'. | 627 | * @return the result of interpreting the object as an instance of '<em>If Else</em>'. |
| 732 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 628 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 733 | * @generated | 629 | * @generated |
| 734 | */ | 630 | */ |
| 735 | public T caseEqualsSymbol(EqualsSymbol object) | 631 | public T caseIfElse(IfElse object) |
| 736 | { | 632 | { |
| 737 | return null; | 633 | return null; |
| 738 | } | 634 | } |
| 739 | 635 | ||
| 740 | /** | 636 | /** |
| 741 | * Returns the result of interpreting the object as an instance of '<em>Data Symbol</em>'. | 637 | * Returns the result of interpreting the object as an instance of '<em>Case</em>'. |
| 742 | * <!-- begin-user-doc --> | 638 | * <!-- begin-user-doc --> |
| 743 | * This implementation returns null; | 639 | * This implementation returns null; |
| 744 | * returning a non-null result will terminate the switch. | 640 | * returning a non-null result will terminate the switch. |
| 745 | * <!-- end-user-doc --> | 641 | * <!-- end-user-doc --> |
| 746 | * @param object the target of the switch. | 642 | * @param object the target of the switch. |
| 747 | * @return the result of interpreting the object as an instance of '<em>Data Symbol</em>'. | 643 | * @return the result of interpreting the object as an instance of '<em>Case</em>'. |
| 748 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 644 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 749 | * @generated | 645 | * @generated |
| 750 | */ | 646 | */ |
| 751 | public T caseDataSymbol(DataSymbol object) | 647 | public T caseCase(Case object) |
| 752 | { | 648 | { |
| 753 | return null; | 649 | return null; |
| 754 | } | 650 | } |
| 755 | 651 | ||
| 756 | /** | 652 | /** |
| 757 | * Returns the result of interpreting the object as an instance of '<em>Boolean Symbol</em>'. | 653 | * Returns the result of interpreting the object as an instance of '<em>Count</em>'. |
| 758 | * <!-- begin-user-doc --> | 654 | * <!-- begin-user-doc --> |
| 759 | * This implementation returns null; | 655 | * This implementation returns null; |
| 760 | * returning a non-null result will terminate the switch. | 656 | * returning a non-null result will terminate the switch. |
| 761 | * <!-- end-user-doc --> | 657 | * <!-- end-user-doc --> |
| 762 | * @param object the target of the switch. | 658 | * @param object the target of the switch. |
| 763 | * @return the result of interpreting the object as an instance of '<em>Boolean Symbol</em>'. | 659 | * @return the result of interpreting the object as an instance of '<em>Count</em>'. |
| 764 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 660 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 765 | * @generated | 661 | * @generated |
| 766 | */ | 662 | */ |
| 767 | public T caseBooleanSymbol(BooleanSymbol object) | 663 | public T caseCount(Count object) |
| 768 | { | 664 | { |
| 769 | return null; | 665 | return null; |
| 770 | } | 666 | } |
| 771 | 667 | ||
| 772 | /** | 668 | /** |
| 773 | * Returns the result of interpreting the object as an instance of '<em>Integer Symbol</em>'. | 669 | * Returns the result of interpreting the object as an instance of '<em>Aggregation</em>'. |
| 774 | * <!-- begin-user-doc --> | 670 | * <!-- begin-user-doc --> |
| 775 | * This implementation returns null; | 671 | * This implementation returns null; |
| 776 | * returning a non-null result will terminate the switch. | 672 | * returning a non-null result will terminate the switch. |
| 777 | * <!-- end-user-doc --> | 673 | * <!-- end-user-doc --> |
| 778 | * @param object the target of the switch. | 674 | * @param object the target of the switch. |
| 779 | * @return the result of interpreting the object as an instance of '<em>Integer Symbol</em>'. | 675 | * @return the result of interpreting the object as an instance of '<em>Aggregation</em>'. |
| 780 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 676 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 781 | * @generated | 677 | * @generated |
| 782 | */ | 678 | */ |
| 783 | public T caseIntegerSymbol(IntegerSymbol object) | 679 | public T caseAggregation(Aggregation object) |
| 784 | { | 680 | { |
| 785 | return null; | 681 | return null; |
| 786 | } | 682 | } |
| 787 | 683 | ||
| 788 | /** | 684 | /** |
| 789 | * Returns the result of interpreting the object as an instance of '<em>Real Symbol</em>'. | 685 | * Returns the result of interpreting the object as an instance of '<em>Call</em>'. |
| 790 | * <!-- begin-user-doc --> | 686 | * <!-- begin-user-doc --> |
| 791 | * This implementation returns null; | 687 | * This implementation returns null; |
| 792 | * returning a non-null result will terminate the switch. | 688 | * returning a non-null result will terminate the switch. |
| 793 | * <!-- end-user-doc --> | 689 | * <!-- end-user-doc --> |
| 794 | * @param object the target of the switch. | 690 | * @param object the target of the switch. |
| 795 | * @return the result of interpreting the object as an instance of '<em>Real Symbol</em>'. | 691 | * @return the result of interpreting the object as an instance of '<em>Call</em>'. |
| 796 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 692 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 797 | * @generated | 693 | * @generated |
| 798 | */ | 694 | */ |
| 799 | public T caseRealSymbol(RealSymbol object) | 695 | public T caseCall(Call object) |
| 800 | { | 696 | { |
| 801 | return null; | 697 | return null; |
| 802 | } | 698 | } |
| 803 | 699 | ||
| 804 | /** | 700 | /** |
| 805 | * Returns the result of interpreting the object as an instance of '<em>String Symbol</em>'. | 701 | * Returns the result of interpreting the object as an instance of '<em>Argument List</em>'. |
| 806 | * <!-- begin-user-doc --> | 702 | * <!-- begin-user-doc --> |
| 807 | * This implementation returns null; | 703 | * This implementation returns null; |
| 808 | * returning a non-null result will terminate the switch. | 704 | * returning a non-null result will terminate the switch. |
| 809 | * <!-- end-user-doc --> | 705 | * <!-- end-user-doc --> |
| 810 | * @param object the target of the switch. | 706 | * @param object the target of the switch. |
| 811 | * @return the result of interpreting the object as an instance of '<em>String Symbol</em>'. | 707 | * @return the result of interpreting the object as an instance of '<em>Argument List</em>'. |
| 812 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 708 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 813 | * @generated | 709 | * @generated |
| 814 | */ | 710 | */ |
| 815 | public T caseStringSymbol(StringSymbol object) | 711 | public T caseArgumentList(ArgumentList object) |
| 816 | { | 712 | { |
| 817 | return null; | 713 | return null; |
| 818 | } | 714 | } |
| 819 | 715 | ||
| 820 | /** | 716 | /** |
| 821 | * Returns the result of interpreting the object as an instance of '<em>Complex Object</em>'. | 717 | * Returns the result of interpreting the object as an instance of '<em>Argument</em>'. |
| 822 | * <!-- begin-user-doc --> | 718 | * <!-- begin-user-doc --> |
| 823 | * This implementation returns null; | 719 | * This implementation returns null; |
| 824 | * returning a non-null result will terminate the switch. | 720 | * returning a non-null result will terminate the switch. |
| 825 | * <!-- end-user-doc --> | 721 | * <!-- end-user-doc --> |
| 826 | * @param object the target of the switch. | 722 | * @param object the target of the switch. |
| 827 | * @return the result of interpreting the object as an instance of '<em>Complex Object</em>'. | 723 | * @return the result of interpreting the object as an instance of '<em>Argument</em>'. |
| 828 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 724 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 829 | * @generated | 725 | * @generated |
| 830 | */ | 726 | */ |
| 831 | public T caseComplexObject(ComplexObject object) | 727 | public T caseArgument(Argument object) |
| 832 | { | 728 | { |
| 833 | return null; | 729 | return null; |
| 834 | } | 730 | } |
| 835 | 731 | ||
| 836 | /** | 732 | /** |
| 837 | * Returns the result of interpreting the object as an instance of '<em>Object</em>'. | 733 | * Returns the result of interpreting the object as an instance of '<em>Expression Argument</em>'. |
| 838 | * <!-- begin-user-doc --> | 734 | * <!-- begin-user-doc --> |
| 839 | * This implementation returns null; | 735 | * This implementation returns null; |
| 840 | * returning a non-null result will terminate the switch. | 736 | * returning a non-null result will terminate the switch. |
| 841 | * <!-- end-user-doc --> | 737 | * <!-- end-user-doc --> |
| 842 | * @param object the target of the switch. | 738 | * @param object the target of the switch. |
| 843 | * @return the result of interpreting the object as an instance of '<em>Object</em>'. | 739 | * @return the result of interpreting the object as an instance of '<em>Expression Argument</em>'. |
| 844 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 740 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 845 | * @generated | 741 | * @generated |
| 846 | */ | 742 | */ |
| 847 | public T caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object) | 743 | public T caseExpressionArgument(ExpressionArgument object) |
| 848 | { | 744 | { |
| 849 | return null; | 745 | return null; |
| 850 | } | 746 | } |
| 851 | 747 | ||
| 852 | /** | 748 | /** |
| 853 | * Returns the result of interpreting the object as an instance of '<em>Named Object</em>'. | 749 | * Returns the result of interpreting the object as an instance of '<em>Star Argument</em>'. |
| 854 | * <!-- begin-user-doc --> | 750 | * <!-- begin-user-doc --> |
| 855 | * This implementation returns null; | 751 | * This implementation returns null; |
| 856 | * returning a non-null result will terminate the switch. | 752 | * returning a non-null result will terminate the switch. |
| 857 | * <!-- end-user-doc --> | 753 | * <!-- end-user-doc --> |
| 858 | * @param object the target of the switch. | 754 | * @param object the target of the switch. |
| 859 | * @return the result of interpreting the object as an instance of '<em>Named Object</em>'. | 755 | * @return the result of interpreting the object as an instance of '<em>Star Argument</em>'. |
| 860 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 756 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 861 | * @generated | 757 | * @generated |
| 862 | */ | 758 | */ |
| 863 | public T caseNamedObject(NamedObject object) | 759 | public T caseStarArgument(StarArgument object) |
| 864 | { | 760 | { |
| 865 | return null; | 761 | return null; |
| 866 | } | 762 | } |
| 867 | 763 | ||
| 868 | /** | 764 | /** |
| 869 | * Returns the result of interpreting the object as an instance of '<em>Unnamed Object</em>'. | 765 | * Returns the result of interpreting the object as an instance of '<em>Typed Argument</em>'. |
| 870 | * <!-- begin-user-doc --> | 766 | * <!-- begin-user-doc --> |
| 871 | * This implementation returns null; | 767 | * This implementation returns null; |
| 872 | * returning a non-null result will terminate the switch. | 768 | * returning a non-null result will terminate the switch. |
| 873 | * <!-- end-user-doc --> | 769 | * <!-- end-user-doc --> |
| 874 | * @param object the target of the switch. | 770 | * @param object the target of the switch. |
| 875 | * @return the result of interpreting the object as an instance of '<em>Unnamed Object</em>'. | 771 | * @return the result of interpreting the object as an instance of '<em>Typed Argument</em>'. |
| 876 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 772 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 877 | * @generated | 773 | * @generated |
| 878 | */ | 774 | */ |
| 879 | public T caseUnnamedObject(UnnamedObject object) | 775 | public T caseTypedArgument(TypedArgument object) |
| 880 | { | 776 | { |
| 881 | return null; | 777 | return null; |
| 882 | } | 778 | } |
| 883 | 779 | ||
| 884 | /** | 780 | /** |
| 885 | * Returns the result of interpreting the object as an instance of '<em>Data Object</em>'. | 781 | * Returns the result of interpreting the object as an instance of '<em>Typed Star Argument</em>'. |
| 886 | * <!-- begin-user-doc --> | 782 | * <!-- begin-user-doc --> |
| 887 | * This implementation returns null; | 783 | * This implementation returns null; |
| 888 | * returning a non-null result will terminate the switch. | 784 | * returning a non-null result will terminate the switch. |
| 889 | * <!-- end-user-doc --> | 785 | * <!-- end-user-doc --> |
| 890 | * @param object the target of the switch. | 786 | * @param object the target of the switch. |
| 891 | * @return the result of interpreting the object as an instance of '<em>Data Object</em>'. | 787 | * @return the result of interpreting the object as an instance of '<em>Typed Star Argument</em>'. |
| 892 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 788 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 893 | * @generated | 789 | * @generated |
| 894 | */ | 790 | */ |
| 895 | public T caseDataObject(DataObject object) | 791 | public T caseTypedStarArgument(TypedStarArgument object) |
| 896 | { | 792 | { |
| 897 | return null; | 793 | return null; |
| 898 | } | 794 | } |
| 899 | 795 | ||
| 900 | /** | 796 | /** |
| 901 | * Returns the result of interpreting the object as an instance of '<em>Boolean Object</em>'. | 797 | * Returns the result of interpreting the object as an instance of '<em>Reference</em>'. |
| 902 | * <!-- begin-user-doc --> | 798 | * <!-- begin-user-doc --> |
| 903 | * This implementation returns null; | 799 | * This implementation returns null; |
| 904 | * returning a non-null result will terminate the switch. | 800 | * returning a non-null result will terminate the switch. |
| 905 | * <!-- end-user-doc --> | 801 | * <!-- end-user-doc --> |
| 906 | * @param object the target of the switch. | 802 | * @param object the target of the switch. |
| 907 | * @return the result of interpreting the object as an instance of '<em>Boolean Object</em>'. | 803 | * @return the result of interpreting the object as an instance of '<em>Reference</em>'. |
| 908 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 804 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 909 | * @generated | 805 | * @generated |
| 910 | */ | 806 | */ |
| 911 | public T caseBooleanObject(BooleanObject object) | 807 | public T caseReference(Reference object) |
| 912 | { | 808 | { |
| 913 | return null; | 809 | return null; |
| 914 | } | 810 | } |
| 915 | 811 | ||
| 916 | /** | 812 | /** |
| 917 | * Returns the result of interpreting the object as an instance of '<em>Int Object</em>'. | 813 | * Returns the result of interpreting the object as an instance of '<em>Interval</em>'. |
| 918 | * <!-- begin-user-doc --> | 814 | * <!-- begin-user-doc --> |
| 919 | * This implementation returns null; | 815 | * This implementation returns null; |
| 920 | * returning a non-null result will terminate the switch. | 816 | * returning a non-null result will terminate the switch. |
| 921 | * <!-- end-user-doc --> | 817 | * <!-- end-user-doc --> |
| 922 | * @param object the target of the switch. | 818 | * @param object the target of the switch. |
| 923 | * @return the result of interpreting the object as an instance of '<em>Int Object</em>'. | 819 | * @return the result of interpreting the object as an instance of '<em>Interval</em>'. |
| 924 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 820 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 925 | * @generated | 821 | * @generated |
| 926 | */ | 822 | */ |
| 927 | public T caseIntObject(IntObject object) | 823 | public T caseInterval(Interval object) |
| 928 | { | 824 | { |
| 929 | return null; | 825 | return null; |
| 930 | } | 826 | } |
| 931 | 827 | ||
| 932 | /** | 828 | /** |
| 933 | * Returns the result of interpreting the object as an instance of '<em>Real Object</em>'. | 829 | * Returns the result of interpreting the object as an instance of '<em>Literal</em>'. |
| 934 | * <!-- begin-user-doc --> | ||
| 935 | * This implementation returns null; | ||
| 936 | * returning a non-null result will terminate the switch. | ||
| 937 | * <!-- end-user-doc --> | ||
| 938 | * @param object the target of the switch. | ||
| 939 | * @return the result of interpreting the object as an instance of '<em>Real Object</em>'. | ||
| 940 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
| 941 | * @generated | ||
| 942 | */ | ||
| 943 | public T caseRealObject(RealObject object) | ||
| 944 | { | ||
| 945 | return null; | ||
| 946 | } | ||
| 947 | |||
| 948 | /** | ||
| 949 | * Returns the result of interpreting the object as an instance of '<em>String Object</em>'. | ||
| 950 | * <!-- begin-user-doc --> | ||
| 951 | * This implementation returns null; | ||
| 952 | * returning a non-null result will terminate the switch. | ||
| 953 | * <!-- end-user-doc --> | ||
| 954 | * @param object the target of the switch. | ||
| 955 | * @return the result of interpreting the object as an instance of '<em>String Object</em>'. | ||
| 956 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
| 957 | * @generated | ||
| 958 | */ | ||
| 959 | public T caseStringObject(StringObject object) | ||
| 960 | { | ||
| 961 | return null; | ||
| 962 | } | ||
| 963 | |||
| 964 | /** | ||
| 965 | * Returns the result of interpreting the object as an instance of '<em>Predicate</em>'. | ||
| 966 | * <!-- begin-user-doc --> | ||
| 967 | * This implementation returns null; | ||
| 968 | * returning a non-null result will terminate the switch. | ||
| 969 | * <!-- end-user-doc --> | ||
| 970 | * @param object the target of the switch. | ||
| 971 | * @return the result of interpreting the object as an instance of '<em>Predicate</em>'. | ||
| 972 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
| 973 | * @generated | ||
| 974 | */ | ||
| 975 | public T casePredicate(Predicate object) | ||
| 976 | { | ||
| 977 | return null; | ||
| 978 | } | ||
| 979 | |||
| 980 | /** | ||
| 981 | * Returns the result of interpreting the object as an instance of '<em>Parameter</em>'. | ||
| 982 | * <!-- begin-user-doc --> | ||
| 983 | * This implementation returns null; | ||
| 984 | * returning a non-null result will terminate the switch. | ||
| 985 | * <!-- end-user-doc --> | ||
| 986 | * @param object the target of the switch. | ||
| 987 | * @return the result of interpreting the object as an instance of '<em>Parameter</em>'. | ||
| 988 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
| 989 | * @generated | ||
| 990 | */ | ||
| 991 | public T caseParameter(Parameter object) | ||
| 992 | { | ||
| 993 | return null; | ||
| 994 | } | ||
| 995 | |||
| 996 | /** | ||
| 997 | * Returns the result of interpreting the object as an instance of '<em>Pattern Body</em>'. | ||
| 998 | * <!-- begin-user-doc --> | 830 | * <!-- begin-user-doc --> |
| 999 | * This implementation returns null; | 831 | * This implementation returns null; |
| 1000 | * returning a non-null result will terminate the switch. | 832 | * returning a non-null result will terminate the switch. |
| 1001 | * <!-- end-user-doc --> | 833 | * <!-- end-user-doc --> |
| 1002 | * @param object the target of the switch. | 834 | * @param object the target of the switch. |
| 1003 | * @return the result of interpreting the object as an instance of '<em>Pattern Body</em>'. | 835 | * @return the result of interpreting the object as an instance of '<em>Literal</em>'. |
| 1004 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 836 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1005 | * @generated | 837 | * @generated |
| 1006 | */ | 838 | */ |
| 1007 | public T casePatternBody(PatternBody object) | 839 | public T caseLiteral(Literal object) |
| 1008 | { | 840 | { |
| 1009 | return null; | 841 | return null; |
| 1010 | } | 842 | } |
| 1011 | 843 | ||
| 1012 | /** | 844 | /** |
| 1013 | * Returns the result of interpreting the object as an instance of '<em>Polarity</em>'. | 845 | * Returns the result of interpreting the object as an instance of '<em>Logic Literal</em>'. |
| 1014 | * <!-- begin-user-doc --> | 846 | * <!-- begin-user-doc --> |
| 1015 | * This implementation returns null; | 847 | * This implementation returns null; |
| 1016 | * returning a non-null result will terminate the switch. | 848 | * returning a non-null result will terminate the switch. |
| 1017 | * <!-- end-user-doc --> | 849 | * <!-- end-user-doc --> |
| 1018 | * @param object the target of the switch. | 850 | * @param object the target of the switch. |
| 1019 | * @return the result of interpreting the object as an instance of '<em>Polarity</em>'. | 851 | * @return the result of interpreting the object as an instance of '<em>Logic Literal</em>'. |
| 1020 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 852 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1021 | * @generated | 853 | * @generated |
| 1022 | */ | 854 | */ |
| 1023 | public T casePolarity(Polarity object) | 855 | public T caseLogicLiteral(LogicLiteral object) |
| 1024 | { | 856 | { |
| 1025 | return null; | 857 | return null; |
| 1026 | } | 858 | } |
| 1027 | 859 | ||
| 1028 | /** | 860 | /** |
| 1029 | * Returns the result of interpreting the object as an instance of '<em>Constraint</em>'. | 861 | * Returns the result of interpreting the object as an instance of '<em>Numeric Literal</em>'. |
| 1030 | * <!-- begin-user-doc --> | 862 | * <!-- begin-user-doc --> |
| 1031 | * This implementation returns null; | 863 | * This implementation returns null; |
| 1032 | * returning a non-null result will terminate the switch. | 864 | * returning a non-null result will terminate the switch. |
| 1033 | * <!-- end-user-doc --> | 865 | * <!-- end-user-doc --> |
| 1034 | * @param object the target of the switch. | 866 | * @param object the target of the switch. |
| 1035 | * @return the result of interpreting the object as an instance of '<em>Constraint</em>'. | 867 | * @return the result of interpreting the object as an instance of '<em>Numeric Literal</em>'. |
| 1036 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 868 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1037 | * @generated | 869 | * @generated |
| 1038 | */ | 870 | */ |
| 1039 | public T caseConstraint(Constraint object) | 871 | public T caseNumericLiteral(NumericLiteral object) |
| 1040 | { | 872 | { |
| 1041 | return null; | 873 | return null; |
| 1042 | } | 874 | } |
| 1043 | 875 | ||
| 1044 | /** | 876 | /** |
| 1045 | * Returns the result of interpreting the object as an instance of '<em>Closure Type</em>'. | 877 | * Returns the result of interpreting the object as an instance of '<em>Infinity Literal</em>'. |
| 1046 | * <!-- begin-user-doc --> | 878 | * <!-- begin-user-doc --> |
| 1047 | * This implementation returns null; | 879 | * This implementation returns null; |
| 1048 | * returning a non-null result will terminate the switch. | 880 | * returning a non-null result will terminate the switch. |
| 1049 | * <!-- end-user-doc --> | 881 | * <!-- end-user-doc --> |
| 1050 | * @param object the target of the switch. | 882 | * @param object the target of the switch. |
| 1051 | * @return the result of interpreting the object as an instance of '<em>Closure Type</em>'. | 883 | * @return the result of interpreting the object as an instance of '<em>Infinity Literal</em>'. |
| 1052 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 884 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1053 | * @generated | 885 | * @generated |
| 1054 | */ | 886 | */ |
| 1055 | public T caseClosureType(ClosureType object) | 887 | public T caseInfinityLiteral(InfinityLiteral object) |
| 1056 | { | 888 | { |
| 1057 | return null; | 889 | return null; |
| 1058 | } | 890 | } |
| 1059 | 891 | ||
| 1060 | /** | 892 | /** |
| 1061 | * Returns the result of interpreting the object as an instance of '<em>Literal</em>'. | 893 | * Returns the result of interpreting the object as an instance of '<em>Empty Interval Literal</em>'. |
| 1062 | * <!-- begin-user-doc --> | 894 | * <!-- begin-user-doc --> |
| 1063 | * This implementation returns null; | 895 | * This implementation returns null; |
| 1064 | * returning a non-null result will terminate the switch. | 896 | * returning a non-null result will terminate the switch. |
| 1065 | * <!-- end-user-doc --> | 897 | * <!-- end-user-doc --> |
| 1066 | * @param object the target of the switch. | 898 | * @param object the target of the switch. |
| 1067 | * @return the result of interpreting the object as an instance of '<em>Literal</em>'. | 899 | * @return the result of interpreting the object as an instance of '<em>Empty Interval Literal</em>'. |
| 1068 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 900 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1069 | * @generated | 901 | * @generated |
| 1070 | */ | 902 | */ |
| 1071 | public T caseLiteral(Literal object) | 903 | public T caseEmptyIntervalLiteral(EmptyIntervalLiteral object) |
| 1072 | { | 904 | { |
| 1073 | return null; | 905 | return null; |
| 1074 | } | 906 | } |
| 1075 | 907 | ||
| 1076 | /** | 908 | /** |
| 1077 | * Returns the result of interpreting the object as an instance of '<em>Variable</em>'. | 909 | * Returns the result of interpreting the object as an instance of '<em>String Literal</em>'. |
| 1078 | * <!-- begin-user-doc --> | 910 | * <!-- begin-user-doc --> |
| 1079 | * This implementation returns null; | 911 | * This implementation returns null; |
| 1080 | * returning a non-null result will terminate the switch. | 912 | * returning a non-null result will terminate the switch. |
| 1081 | * <!-- end-user-doc --> | 913 | * <!-- end-user-doc --> |
| 1082 | * @param object the target of the switch. | 914 | * @param object the target of the switch. |
| 1083 | * @return the result of interpreting the object as an instance of '<em>Variable</em>'. | 915 | * @return the result of interpreting the object as an instance of '<em>String Literal</em>'. |
| 1084 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 916 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1085 | * @generated | 917 | * @generated |
| 1086 | */ | 918 | */ |
| 1087 | public T caseVariable(Variable object) | 919 | public T caseStringLiteral(StringLiteral object) |
| 1088 | { | 920 | { |
| 1089 | return null; | 921 | return null; |
| 1090 | } | 922 | } |
| 1091 | 923 | ||
| 1092 | /** | 924 | /** |
| 1093 | * Returns the result of interpreting the object as an instance of '<em>All Instances</em>'. | 925 | * Returns the result of interpreting the object as an instance of '<em>Class Definition</em>'. |
| 1094 | * <!-- begin-user-doc --> | 926 | * <!-- begin-user-doc --> |
| 1095 | * This implementation returns null; | 927 | * This implementation returns null; |
| 1096 | * returning a non-null result will terminate the switch. | 928 | * returning a non-null result will terminate the switch. |
| 1097 | * <!-- end-user-doc --> | 929 | * <!-- end-user-doc --> |
| 1098 | * @param object the target of the switch. | 930 | * @param object the target of the switch. |
| 1099 | * @return the result of interpreting the object as an instance of '<em>All Instances</em>'. | 931 | * @return the result of interpreting the object as an instance of '<em>Class Definition</em>'. |
| 1100 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 932 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1101 | * @generated | 933 | * @generated |
| 1102 | */ | 934 | */ |
| 1103 | public T caseAllInstances(AllInstances object) | 935 | public T caseClassDefinition(ClassDefinition object) |
| 1104 | { | 936 | { |
| 1105 | return null; | 937 | return null; |
| 1106 | } | 938 | } |
| 1107 | 939 | ||
| 1108 | /** | 940 | /** |
| 1109 | * Returns the result of interpreting the object as an instance of '<em>All Objects</em>'. | 941 | * Returns the result of interpreting the object as an instance of '<em>Member Definition</em>'. |
| 1110 | * <!-- begin-user-doc --> | 942 | * <!-- begin-user-doc --> |
| 1111 | * This implementation returns null; | 943 | * This implementation returns null; |
| 1112 | * returning a non-null result will terminate the switch. | 944 | * returning a non-null result will terminate the switch. |
| 1113 | * <!-- end-user-doc --> | 945 | * <!-- end-user-doc --> |
| 1114 | * @param object the target of the switch. | 946 | * @param object the target of the switch. |
| 1115 | * @return the result of interpreting the object as an instance of '<em>All Objects</em>'. | 947 | * @return the result of interpreting the object as an instance of '<em>Member Definition</em>'. |
| 1116 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 948 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1117 | * @generated | 949 | * @generated |
| 1118 | */ | 950 | */ |
| 1119 | public T caseAllObjects(AllObjects object) | 951 | public T caseMemberDefinition(MemberDefinition object) |
| 1120 | { | 952 | { |
| 1121 | return null; | 953 | return null; |
| 1122 | } | 954 | } |
| 1123 | 955 | ||
| 1124 | /** | 956 | /** |
| 1125 | * Returns the result of interpreting the object as an instance of '<em>Default Interpretation</em>'. | 957 | * Returns the result of interpreting the object as an instance of '<em>Multiplicity</em>'. |
| 1126 | * <!-- begin-user-doc --> | 958 | * <!-- begin-user-doc --> |
| 1127 | * This implementation returns null; | 959 | * This implementation returns null; |
| 1128 | * returning a non-null result will terminate the switch. | 960 | * returning a non-null result will terminate the switch. |
| 1129 | * <!-- end-user-doc --> | 961 | * <!-- end-user-doc --> |
| 1130 | * @param object the target of the switch. | 962 | * @param object the target of the switch. |
| 1131 | * @return the result of interpreting the object as an instance of '<em>Default Interpretation</em>'. | 963 | * @return the result of interpreting the object as an instance of '<em>Multiplicity</em>'. |
| 1132 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 964 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1133 | * @generated | 965 | * @generated |
| 1134 | */ | 966 | */ |
| 1135 | public T caseDefaultInterpretation(DefaultInterpretation object) | 967 | public T caseMultiplicity(Multiplicity object) |
| 1136 | { | 968 | { |
| 1137 | return null; | 969 | return null; |
| 1138 | } | 970 | } |
| 1139 | 971 | ||
| 1140 | /** | 972 | /** |
| 1141 | * Returns the result of interpreting the object as an instance of '<em>CD Interpretation</em>'. | 973 | * Returns the result of interpreting the object as an instance of '<em>Many Multiplicity</em>'. |
| 1142 | * <!-- begin-user-doc --> | 974 | * <!-- begin-user-doc --> |
| 1143 | * This implementation returns null; | 975 | * This implementation returns null; |
| 1144 | * returning a non-null result will terminate the switch. | 976 | * returning a non-null result will terminate the switch. |
| 1145 | * <!-- end-user-doc --> | 977 | * <!-- end-user-doc --> |
| 1146 | * @param object the target of the switch. | 978 | * @param object the target of the switch. |
| 1147 | * @return the result of interpreting the object as an instance of '<em>CD Interpretation</em>'. | 979 | * @return the result of interpreting the object as an instance of '<em>Many Multiplicity</em>'. |
| 1148 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 980 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1149 | * @generated | 981 | * @generated |
| 1150 | */ | 982 | */ |
| 1151 | public T caseCDInterpretation(CDInterpretation object) | 983 | public T caseManyMultiplicity(ManyMultiplicity object) |
| 1152 | { | 984 | { |
| 1153 | return null; | 985 | return null; |
| 1154 | } | 986 | } |
| 1155 | 987 | ||
| 1156 | /** | 988 | /** |
| 1157 | * Returns the result of interpreting the object as an instance of '<em>Class Interpretation</em>'. | 989 | * Returns the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'. |
| 1158 | * <!-- begin-user-doc --> | 990 | * <!-- begin-user-doc --> |
| 1159 | * This implementation returns null; | 991 | * This implementation returns null; |
| 1160 | * returning a non-null result will terminate the switch. | 992 | * returning a non-null result will terminate the switch. |
| 1161 | * <!-- end-user-doc --> | 993 | * <!-- end-user-doc --> |
| 1162 | * @param object the target of the switch. | 994 | * @param object the target of the switch. |
| 1163 | * @return the result of interpreting the object as an instance of '<em>Class Interpretation</em>'. | 995 | * @return the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'. |
| 1164 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 996 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1165 | * @generated | 997 | * @generated |
| 1166 | */ | 998 | */ |
| 1167 | public T caseClassInterpretation(ClassInterpretation object) | 999 | public T caseExactMultiplicity(ExactMultiplicity object) |
| 1168 | { | 1000 | { |
| 1169 | return null; | 1001 | return null; |
| 1170 | } | 1002 | } |
| 1171 | 1003 | ||
| 1172 | /** | 1004 | /** |
| 1173 | * Returns the result of interpreting the object as an instance of '<em>Enum Interpretation</em>'. | 1005 | * Returns the result of interpreting the object as an instance of '<em>Bounded Multiplicity</em>'. |
| 1174 | * <!-- begin-user-doc --> | 1006 | * <!-- begin-user-doc --> |
| 1175 | * This implementation returns null; | 1007 | * This implementation returns null; |
| 1176 | * returning a non-null result will terminate the switch. | 1008 | * returning a non-null result will terminate the switch. |
| 1177 | * <!-- end-user-doc --> | 1009 | * <!-- end-user-doc --> |
| 1178 | * @param object the target of the switch. | 1010 | * @param object the target of the switch. |
| 1179 | * @return the result of interpreting the object as an instance of '<em>Enum Interpretation</em>'. | 1011 | * @return the result of interpreting the object as an instance of '<em>Bounded Multiplicity</em>'. |
| 1180 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1012 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1181 | * @generated | 1013 | * @generated |
| 1182 | */ | 1014 | */ |
| 1183 | public T caseEnumInterpretation(EnumInterpretation object) | 1015 | public T caseBoundedMultiplicity(BoundedMultiplicity object) |
| 1184 | { | 1016 | { |
| 1185 | return null; | 1017 | return null; |
| 1186 | } | 1018 | } |
| 1187 | 1019 | ||
| 1188 | /** | 1020 | /** |
| 1189 | * Returns the result of interpreting the object as an instance of '<em>Field Relation Interpretation</em>'. | 1021 | * Returns the result of interpreting the object as an instance of '<em>Scope Definition</em>'. |
| 1190 | * <!-- begin-user-doc --> | 1022 | * <!-- begin-user-doc --> |
| 1191 | * This implementation returns null; | 1023 | * This implementation returns null; |
| 1192 | * returning a non-null result will terminate the switch. | 1024 | * returning a non-null result will terminate the switch. |
| 1193 | * <!-- end-user-doc --> | 1025 | * <!-- end-user-doc --> |
| 1194 | * @param object the target of the switch. | 1026 | * @param object the target of the switch. |
| 1195 | * @return the result of interpreting the object as an instance of '<em>Field Relation Interpretation</em>'. | 1027 | * @return the result of interpreting the object as an instance of '<em>Scope Definition</em>'. |
| 1196 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1028 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1197 | * @generated | 1029 | * @generated |
| 1198 | */ | 1030 | */ |
| 1199 | public T caseFieldRelationInterpretation(FieldRelationInterpretation object) | 1031 | public T caseScopeDefinition(ScopeDefinition object) |
| 1200 | { | 1032 | { |
| 1201 | return null; | 1033 | return null; |
| 1202 | } | 1034 | } |
| 1203 | 1035 | ||
| 1204 | /** | 1036 | /** |
| 1205 | * Returns the result of interpreting the object as an instance of '<em>Global Relation Interpretation</em>'. | 1037 | * Returns the result of interpreting the object as an instance of '<em>Exact Scope Definition</em>'. |
| 1206 | * <!-- begin-user-doc --> | 1038 | * <!-- begin-user-doc --> |
| 1207 | * This implementation returns null; | 1039 | * This implementation returns null; |
| 1208 | * returning a non-null result will terminate the switch. | 1040 | * returning a non-null result will terminate the switch. |
| 1209 | * <!-- end-user-doc --> | 1041 | * <!-- end-user-doc --> |
| 1210 | * @param object the target of the switch. | 1042 | * @param object the target of the switch. |
| 1211 | * @return the result of interpreting the object as an instance of '<em>Global Relation Interpretation</em>'. | 1043 | * @return the result of interpreting the object as an instance of '<em>Exact Scope Definition</em>'. |
| 1212 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1044 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1213 | * @generated | 1045 | * @generated |
| 1214 | */ | 1046 | */ |
| 1215 | public T caseGlobalRelationInterpretation(GlobalRelationInterpretation object) | 1047 | public T caseExactScopeDefinition(ExactScopeDefinition object) |
| 1216 | { | 1048 | { |
| 1217 | return null; | 1049 | return null; |
| 1218 | } | 1050 | } |
| 1219 | 1051 | ||
| 1220 | /** | 1052 | /** |
| 1221 | * Returns the result of interpreting the object as an instance of '<em>Multiplicity Definition</em>'. | 1053 | * Returns the result of interpreting the object as an instance of '<em>Bounded Scope Definition</em>'. |
| 1222 | * <!-- begin-user-doc --> | 1054 | * <!-- begin-user-doc --> |
| 1223 | * This implementation returns null; | 1055 | * This implementation returns null; |
| 1224 | * returning a non-null result will terminate the switch. | 1056 | * returning a non-null result will terminate the switch. |
| 1225 | * <!-- end-user-doc --> | 1057 | * <!-- end-user-doc --> |
| 1226 | * @param object the target of the switch. | 1058 | * @param object the target of the switch. |
| 1227 | * @return the result of interpreting the object as an instance of '<em>Multiplicity Definition</em>'. | 1059 | * @return the result of interpreting the object as an instance of '<em>Bounded Scope Definition</em>'. |
| 1228 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1060 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1229 | * @generated | 1061 | * @generated |
| 1230 | */ | 1062 | */ |
| 1231 | public T caseMultiplicityDefinition(MultiplicityDefinition object) | 1063 | public T caseBoundedScopeDefinition(BoundedScopeDefinition object) |
| 1232 | { | 1064 | { |
| 1233 | return null; | 1065 | return null; |
| 1234 | } | 1066 | } |
| 1235 | 1067 | ||
| 1236 | /** | 1068 | /** |
| 1237 | * Returns the result of interpreting the object as an instance of '<em>Boolean True</em>'. | 1069 | * Returns the result of interpreting the object as an instance of '<em>Lower Bounded Scope Definition</em>'. |
| 1238 | * <!-- begin-user-doc --> | 1070 | * <!-- begin-user-doc --> |
| 1239 | * This implementation returns null; | 1071 | * This implementation returns null; |
| 1240 | * returning a non-null result will terminate the switch. | 1072 | * returning a non-null result will terminate the switch. |
| 1241 | * <!-- end-user-doc --> | 1073 | * <!-- end-user-doc --> |
| 1242 | * @param object the target of the switch. | 1074 | * @param object the target of the switch. |
| 1243 | * @return the result of interpreting the object as an instance of '<em>Boolean True</em>'. | 1075 | * @return the result of interpreting the object as an instance of '<em>Lower Bounded Scope Definition</em>'. |
| 1244 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1076 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1245 | * @generated | 1077 | * @generated |
| 1246 | */ | 1078 | */ |
| 1247 | public T caseBooleanTrue(BooleanTrue object) | 1079 | public T caseLowerBoundedScopeDefinition(LowerBoundedScopeDefinition object) |
| 1248 | { | 1080 | { |
| 1249 | return null; | 1081 | return null; |
| 1250 | } | 1082 | } |
| 1251 | 1083 | ||
| 1252 | /** | 1084 | /** |
| 1253 | * Returns the result of interpreting the object as an instance of '<em>Boolean False</em>'. | 1085 | * Returns the result of interpreting the object as an instance of '<em>Objective Definition</em>'. |
| 1254 | * <!-- begin-user-doc --> | 1086 | * <!-- begin-user-doc --> |
| 1255 | * This implementation returns null; | 1087 | * This implementation returns null; |
| 1256 | * returning a non-null result will terminate the switch. | 1088 | * returning a non-null result will terminate the switch. |
| 1257 | * <!-- end-user-doc --> | 1089 | * <!-- end-user-doc --> |
| 1258 | * @param object the target of the switch. | 1090 | * @param object the target of the switch. |
| 1259 | * @return the result of interpreting the object as an instance of '<em>Boolean False</em>'. | 1091 | * @return the result of interpreting the object as an instance of '<em>Objective Definition</em>'. |
| 1260 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1092 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1261 | * @generated | 1093 | * @generated |
| 1262 | */ | 1094 | */ |
| 1263 | public T caseBooleanFalse(BooleanFalse object) | 1095 | public T caseObjectiveDefinition(ObjectiveDefinition object) |
| 1264 | { | 1096 | { |
| 1265 | return null; | 1097 | return null; |
| 1266 | } | 1098 | } |
| 1267 | 1099 | ||
| 1268 | /** | 1100 | /** |
| 1269 | * Returns the result of interpreting the object as an instance of '<em>True</em>'. | 1101 | * Returns the result of interpreting the object as an instance of '<em>Named Element</em>'. |
| 1270 | * <!-- begin-user-doc --> | 1102 | * <!-- begin-user-doc --> |
| 1271 | * This implementation returns null; | 1103 | * This implementation returns null; |
| 1272 | * returning a non-null result will terminate the switch. | 1104 | * returning a non-null result will terminate the switch. |
| 1273 | * <!-- end-user-doc --> | 1105 | * <!-- end-user-doc --> |
| 1274 | * @param object the target of the switch. | 1106 | * @param object the target of the switch. |
| 1275 | * @return the result of interpreting the object as an instance of '<em>True</em>'. | 1107 | * @return the result of interpreting the object as an instance of '<em>Named Element</em>'. |
| 1276 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1108 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1277 | * @generated | 1109 | * @generated |
| 1278 | */ | 1110 | */ |
| 1279 | public T caseTrue(True object) | 1111 | public T caseNamedElement(NamedElement object) |
| 1280 | { | 1112 | { |
| 1281 | return null; | 1113 | return null; |
| 1282 | } | 1114 | } |
| 1283 | 1115 | ||
| 1284 | /** | 1116 | /** |
| 1285 | * Returns the result of interpreting the object as an instance of '<em>False</em>'. | 1117 | * Returns the result of interpreting the object as an instance of '<em>Assertion</em>'. |
| 1286 | * <!-- begin-user-doc --> | 1118 | * <!-- begin-user-doc --> |
| 1287 | * This implementation returns null; | 1119 | * This implementation returns null; |
| 1288 | * returning a non-null result will terminate the switch. | 1120 | * returning a non-null result will terminate the switch. |
| 1289 | * <!-- end-user-doc --> | 1121 | * <!-- end-user-doc --> |
| 1290 | * @param object the target of the switch. | 1122 | * @param object the target of the switch. |
| 1291 | * @return the result of interpreting the object as an instance of '<em>False</em>'. | 1123 | * @return the result of interpreting the object as an instance of '<em>Assertion</em>'. |
| 1292 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1124 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1293 | * @generated | 1125 | * @generated |
| 1294 | */ | 1126 | */ |
| 1295 | public T caseFalse(False object) | 1127 | public T caseAssertion(Assertion object) |
| 1296 | { | 1128 | { |
| 1297 | return null; | 1129 | return null; |
| 1298 | } | 1130 | } |
| 1299 | 1131 | ||
| 1300 | /** | 1132 | /** |
| 1301 | * Returns the result of interpreting the object as an instance of '<em>Unknown</em>'. | 1133 | * Returns the result of interpreting the object as an instance of '<em>Disjunction</em>'. |
| 1302 | * <!-- begin-user-doc --> | 1134 | * <!-- begin-user-doc --> |
| 1303 | * This implementation returns null; | 1135 | * This implementation returns null; |
| 1304 | * returning a non-null result will terminate the switch. | 1136 | * returning a non-null result will terminate the switch. |
| 1305 | * <!-- end-user-doc --> | 1137 | * <!-- end-user-doc --> |
| 1306 | * @param object the target of the switch. | 1138 | * @param object the target of the switch. |
| 1307 | * @return the result of interpreting the object as an instance of '<em>Unknown</em>'. | 1139 | * @return the result of interpreting the object as an instance of '<em>Disjunction</em>'. |
| 1308 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1140 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1309 | * @generated | 1141 | * @generated |
| 1310 | */ | 1142 | */ |
| 1311 | public T caseUnknown(Unknown object) | 1143 | public T caseDisjunction(Disjunction object) |
| 1312 | { | 1144 | { |
| 1313 | return null; | 1145 | return null; |
| 1314 | } | 1146 | } |
| 1315 | 1147 | ||
| 1316 | /** | 1148 | /** |
| 1317 | * Returns the result of interpreting the object as an instance of '<em>Error</em>'. | 1149 | * Returns the result of interpreting the object as an instance of '<em>Switch</em>'. |
| 1318 | * <!-- begin-user-doc --> | 1150 | * <!-- begin-user-doc --> |
| 1319 | * This implementation returns null; | 1151 | * This implementation returns null; |
| 1320 | * returning a non-null result will terminate the switch. | 1152 | * returning a non-null result will terminate the switch. |
| 1321 | * <!-- end-user-doc --> | 1153 | * <!-- end-user-doc --> |
| 1322 | * @param object the target of the switch. | 1154 | * @param object the target of the switch. |
| 1323 | * @return the result of interpreting the object as an instance of '<em>Error</em>'. | 1155 | * @return the result of interpreting the object as an instance of '<em>Switch</em>'. |
| 1324 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1156 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1325 | * @generated | 1157 | * @generated |
| 1326 | */ | 1158 | */ |
| 1327 | public T caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object) | 1159 | public T caseSwitch(org.eclipse.viatra.solver.language.solverLanguage.Switch object) |
| 1328 | { | 1160 | { |
| 1329 | return null; | 1161 | return null; |
| 1330 | } | 1162 | } |
| 1331 | 1163 | ||
| 1332 | /** | 1164 | /** |
| 1333 | * Returns the result of interpreting the object as an instance of '<em>Positive</em>'. | 1165 | * Returns the result of interpreting the object as an instance of '<em>Conjunction</em>'. |
| 1334 | * <!-- begin-user-doc --> | 1166 | * <!-- begin-user-doc --> |
| 1335 | * This implementation returns null; | 1167 | * This implementation returns null; |
| 1336 | * returning a non-null result will terminate the switch. | 1168 | * returning a non-null result will terminate the switch. |
| 1337 | * <!-- end-user-doc --> | 1169 | * <!-- end-user-doc --> |
| 1338 | * @param object the target of the switch. | 1170 | * @param object the target of the switch. |
| 1339 | * @return the result of interpreting the object as an instance of '<em>Positive</em>'. | 1171 | * @return the result of interpreting the object as an instance of '<em>Conjunction</em>'. |
| 1340 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1172 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1341 | * @generated | 1173 | * @generated |
| 1342 | */ | 1174 | */ |
| 1343 | public T casePositive(Positive object) | 1175 | public T caseConjunction(Conjunction object) |
| 1344 | { | 1176 | { |
| 1345 | return null; | 1177 | return null; |
| 1346 | } | 1178 | } |
| 1347 | 1179 | ||
| 1348 | /** | 1180 | /** |
| 1349 | * Returns the result of interpreting the object as an instance of '<em>Negative</em>'. | 1181 | * Returns the result of interpreting the object as an instance of '<em>Comparison</em>'. |
| 1350 | * <!-- begin-user-doc --> | 1182 | * <!-- begin-user-doc --> |
| 1351 | * This implementation returns null; | 1183 | * This implementation returns null; |
| 1352 | * returning a non-null result will terminate the switch. | 1184 | * returning a non-null result will terminate the switch. |
| 1353 | * <!-- end-user-doc --> | 1185 | * <!-- end-user-doc --> |
| 1354 | * @param object the target of the switch. | 1186 | * @param object the target of the switch. |
| 1355 | * @return the result of interpreting the object as an instance of '<em>Negative</em>'. | 1187 | * @return the result of interpreting the object as an instance of '<em>Comparison</em>'. |
| 1356 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1188 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1357 | * @generated | 1189 | * @generated |
| 1358 | */ | 1190 | */ |
| 1359 | public T caseNegative(Negative object) | 1191 | public T caseComparison(Comparison object) |
| 1360 | { | 1192 | { |
| 1361 | return null; | 1193 | return null; |
| 1362 | } | 1194 | } |
| 1363 | 1195 | ||
| 1364 | /** | 1196 | /** |
| 1365 | * Returns the result of interpreting the object as an instance of '<em>Reflexive Closure</em>'. | 1197 | * Returns the result of interpreting the object as an instance of '<em>Binary Expression</em>'. |
| 1366 | * <!-- begin-user-doc --> | 1198 | * <!-- begin-user-doc --> |
| 1367 | * This implementation returns null; | 1199 | * This implementation returns null; |
| 1368 | * returning a non-null result will terminate the switch. | 1200 | * returning a non-null result will terminate the switch. |
| 1369 | * <!-- end-user-doc --> | 1201 | * <!-- end-user-doc --> |
| 1370 | * @param object the target of the switch. | 1202 | * @param object the target of the switch. |
| 1371 | * @return the result of interpreting the object as an instance of '<em>Reflexive Closure</em>'. | 1203 | * @return the result of interpreting the object as an instance of '<em>Binary Expression</em>'. |
| 1372 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1204 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1373 | * @generated | 1205 | * @generated |
| 1374 | */ | 1206 | */ |
| 1375 | public T caseReflexiveClosure(ReflexiveClosure object) | 1207 | public T caseBinaryExpression(BinaryExpression object) |
| 1376 | { | 1208 | { |
| 1377 | return null; | 1209 | return null; |
| 1378 | } | 1210 | } |
| 1379 | 1211 | ||
| 1380 | /** | 1212 | /** |
| 1381 | * Returns the result of interpreting the object as an instance of '<em>Irreflexive Closure</em>'. | 1213 | * Returns the result of interpreting the object as an instance of '<em>Unary Expression</em>'. |
| 1382 | * <!-- begin-user-doc --> | 1214 | * <!-- begin-user-doc --> |
| 1383 | * This implementation returns null; | 1215 | * This implementation returns null; |
| 1384 | * returning a non-null result will terminate the switch. | 1216 | * returning a non-null result will terminate the switch. |
| 1385 | * <!-- end-user-doc --> | 1217 | * <!-- end-user-doc --> |
| 1386 | * @param object the target of the switch. | 1218 | * @param object the target of the switch. |
| 1387 | * @return the result of interpreting the object as an instance of '<em>Irreflexive Closure</em>'. | 1219 | * @return the result of interpreting the object as an instance of '<em>Unary Expression</em>'. |
| 1388 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | 1220 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) |
| 1389 | * @generated | 1221 | * @generated |
| 1390 | */ | 1222 | */ |
| 1391 | public T caseIrreflexiveClosure(IrreflexiveClosure object) | 1223 | public T caseUnaryExpression(UnaryExpression object) |
| 1392 | { | 1224 | { |
| 1393 | return null; | 1225 | return null; |
| 1394 | } | 1226 | } |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java index e4313a24..55314a22 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.validation; | 4 | package org.eclipse.viatra.solver.language.validation; |
| 5 | 5 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java index 4247dc60..a229cb60 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java | |||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * generated by Xtext 2.18.0.M3 | 2 | * generated by Xtext 2.21.0 |
| 3 | */ | 3 | */ |
| 4 | package org.eclipse.viatra.solver.language.validation; | 4 | package org.eclipse.viatra.solver.language.validation; |
| 5 | 5 | ||