From d899c1cb4d3b89ccb22d5a13b696c1e014d0a1fa Mon Sep 17 00:00:00 2001 From: Rodolfo Totaro Date: Fri, 16 Dec 2016 22:31:13 +0100 Subject: [PATCH] #190 xtext new plugin generation --- .../META-INF/MANIFEST.MF | 10 +- .../META-INF/MANIFEST.MF | 16 +- .../model/generated/Tqcl.genmodel | 2 +- .../commands/AbstractTqclRuntimeModule.java | 194 + .../eclipse/triquetrum/commands/Tqcl.xtextbin | Bin 0 -> 4813 bytes .../TqclStandaloneSetupGenerated.java | 42 + .../antlr/TqclAntlrTokenFileProvider.java | 16 + .../commands/parser/antlr/TqclParser.java | 40 + .../parser/antlr/internal/InternalTqcl.g | 1385 ++++++ .../parser/antlr/internal/InternalTqcl.tokens | 54 + .../antlr/internal/InternalTqclLexer.java | 1473 ++++++ .../antlr/internal/InternalTqclParser.java | 4213 +++++++++++++++++ .../scoping/AbstractTqclScopeProvider.java | 9 + .../AbstractTqclSemanticSequencer.java | 216 + .../AbstractTqclSyntacticSequencer.java | 107 + .../commands/services/TqclGrammarAccess.java | 520 ++ .../triquetrum/commands/tqcl/Command.java | 20 + .../triquetrum/commands/tqcl/Connect.java | 78 + .../triquetrum/commands/tqcl/Insert.java | 96 + .../triquetrum/commands/tqcl/NamedObj.java | 52 + .../triquetrum/commands/tqcl/Parameter.java | 79 + .../triquetrum/commands/tqcl/TqclFactory.java | 89 + .../triquetrum/commands/tqcl/TqclPackage.java | 572 +++ .../commands/tqcl/TriquetrumScript.java | 44 + .../commands/tqcl/impl/CommandImpl.java | 43 + .../commands/tqcl/impl/ConnectImpl.java | 265 ++ .../commands/tqcl/impl/InsertImpl.java | 312 ++ .../commands/tqcl/impl/NamedObjImpl.java | 178 + .../commands/tqcl/impl/ParameterImpl.java | 234 + .../commands/tqcl/impl/TqclFactoryImpl.java | 167 + .../commands/tqcl/impl/TqclPackageImpl.java | 395 ++ .../tqcl/impl/TriquetrumScriptImpl.java | 168 + .../tqcl/util/TqclAdapterFactory.java | 233 + .../commands/tqcl/util/TqclSwitch.java | 237 + .../validation/AbstractTqclValidator.java | 22 + .../triquetrum/commands/GenerateTqcl.mwe2 | 43 +- .../commands/TqclRuntimeModule.xtend | 11 + .../commands/TqclStandaloneSetup.xtend | 15 + .../commands/generator/TqclGenerator.java | 30 + .../commands/scoping/TqclScopeProvider.java | 15 + .../serializer/TqclSemanticSequencer.java | 8 + .../serializer/TqclSyntacticSequencer.java | 8 + .../commands/validation/TqclValidator.java | 25 + .../commands/.TqclRuntimeModule.xtendbin | Bin 0 -> 1649 bytes .../commands/.TqclStandaloneSetup.xtendbin | Bin 0 -> 1900 bytes .../eclipse/triquetrum/commands/.gitignore | 2 + .../commands/TqclRuntimeModule.java | 13 + .../commands/TqclStandaloneSetup.java | 17 + .../triquetrum/commands/generator/.gitignore | 1 + .../eclipse/triquetrum/commands/ui/.gitignore | 1 + .../commands/ui/contentassist/.gitignore | 1 + 51 files changed, 11752 insertions(+), 19 deletions(-) create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/AbstractTqclRuntimeModule.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/Tqcl.xtextbin create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/TqclStandaloneSetupGenerated.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/TqclAntlrTokenFileProvider.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/TqclParser.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqcl.g create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqcl.tokens create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclLexer.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclParser.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/scoping/AbstractTqclScopeProvider.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSemanticSequencer.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSyntacticSequencer.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/services/TqclGrammarAccess.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Command.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Connect.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Insert.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/NamedObj.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Parameter.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclFactory.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclPackage.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TriquetrumScript.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/CommandImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ConnectImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/InsertImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/NamedObjImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ParameterImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclFactoryImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclPackageImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TriquetrumScriptImpl.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclAdapterFactory.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclSwitch.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/validation/AbstractTqclValidator.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclRuntimeModule.xtend create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclStandaloneSetup.xtend create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/generator/TqclGenerator.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/scoping/TqclScopeProvider.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSemanticSequencer.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSyntacticSequencer.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/validation/TqclValidator.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/.TqclRuntimeModule.xtendbin create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/.TqclStandaloneSetup.xtendbin create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/.gitignore create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/TqclRuntimeModule.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/TqclStandaloneSetup.java create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/generator/.gitignore create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/ui/.gitignore create mode 100644 org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/ui/contentassist/.gitignore diff --git a/org.eclipse.triquetrum.commands.xtext.ide/META-INF/MANIFEST.MF b/org.eclipse.triquetrum.commands.xtext.ide/META-INF/MANIFEST.MF index ee20d119..662cb37b 100644 --- a/org.eclipse.triquetrum.commands.xtext.ide/META-INF/MANIFEST.MF +++ b/org.eclipse.triquetrum.commands.xtext.ide/META-INF/MANIFEST.MF @@ -1,12 +1,8 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: org.eclipse.triquetrum.commands.xtext.ide -Bundle-Vendor: My Company -Bundle-Version: 1.0.0.qualifier -Bundle-SymbolicName: org.eclipse.triquetrum.commands.xtext.ide; singleton:=true +Bundle-SymbolicName: org.eclipse.triquetrum.commands.xtext.ide;singleton:=true +Bundle-Version: 0.0.1.qualifier +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 Bundle-ActivationPolicy: lazy -Require-Bundle: org.eclipse.triquetrum.commands.xtext, - org.eclipse.xtext.ide, - org.eclipse.xtext.xbase.ide -Bundle-RequiredExecutionEnvironment: JavaSE-1.8 diff --git a/org.eclipse.triquetrum.commands.xtext/META-INF/MANIFEST.MF b/org.eclipse.triquetrum.commands.xtext/META-INF/MANIFEST.MF index 0053362c..f1722596 100644 --- a/org.eclipse.triquetrum.commands.xtext/META-INF/MANIFEST.MF +++ b/org.eclipse.triquetrum.commands.xtext/META-INF/MANIFEST.MF @@ -15,6 +15,20 @@ Require-Bundle: org.eclipse.xtext, org.eclipse.xtend.lib, org.eclipse.emf.common, org.eclipse.xtext.common.types, - org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional + org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional, + org.eclipse.xtext.xbase.ui, + org.eclipse.xtext.ui, + org.eclipse.xtext.generator;bundle-version="2.10.0" Bundle-RequiredExecutionEnvironment: JavaSE-1.8 Import-Package: org.apache.log4j +Export-Package: org.eclipse.triquetrum.commands.tqcl, + org.eclipse.triquetrum.commands.validation, + org.eclipse.triquetrum.commands.parser.antlr, + org.eclipse.triquetrum.commands.parser.antlr.internal, + org.eclipse.triquetrum.commands.serializer, + org.eclipse.triquetrum.commands.generator, + org.eclipse.triquetrum.commands, + org.eclipse.triquetrum.commands.tqcl.impl, + org.eclipse.triquetrum.commands.services, + org.eclipse.triquetrum.commands.scoping, + org.eclipse.triquetrum.commands.tqcl.util diff --git a/org.eclipse.triquetrum.commands.xtext/model/generated/Tqcl.genmodel b/org.eclipse.triquetrum.commands.xtext/model/generated/Tqcl.genmodel index f3d2ea02..81e5ac4d 100644 --- a/org.eclipse.triquetrum.commands.xtext/model/generated/Tqcl.genmodel +++ b/org.eclipse.triquetrum.commands.xtext/model/generated/Tqcl.genmodel @@ -1,6 +1,6 @@ diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/AbstractTqclRuntimeModule.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/AbstractTqclRuntimeModule.java new file mode 100644 index 00000000..d0a1f1b9 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/AbstractTqclRuntimeModule.java @@ -0,0 +1,194 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import java.util.Properties; +import org.eclipse.triquetrum.commands.generator.TqclGenerator; +import org.eclipse.triquetrum.commands.parser.antlr.TqclAntlrTokenFileProvider; +import org.eclipse.triquetrum.commands.parser.antlr.TqclParser; +import org.eclipse.triquetrum.commands.parser.antlr.internal.InternalTqclLexer; +import org.eclipse.triquetrum.commands.scoping.TqclScopeProvider; +import org.eclipse.triquetrum.commands.serializer.TqclSemanticSequencer; +import org.eclipse.triquetrum.commands.serializer.TqclSyntacticSequencer; +import org.eclipse.triquetrum.commands.services.TqclGrammarAccess; +import org.eclipse.triquetrum.commands.validation.TqclValidator; +import org.eclipse.xtext.Constants; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.common.types.DefaultCommonTypesRuntimeModule; +import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider; +import org.eclipse.xtext.generator.IGenerator2; +import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider; +import org.eclipse.xtext.naming.IQualifiedNameProvider; +import org.eclipse.xtext.parser.IParser; +import org.eclipse.xtext.parser.ITokenToStringConverter; +import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider; +import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; +import org.eclipse.xtext.parser.antlr.ITokenDefProvider; +import org.eclipse.xtext.parser.antlr.Lexer; +import org.eclipse.xtext.parser.antlr.LexerBindings; +import org.eclipse.xtext.parser.antlr.LexerProvider; +import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.IResourceDescriptions; +import org.eclipse.xtext.resource.containers.IAllContainersState; +import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; +import org.eclipse.xtext.resource.containers.StateBasedContainerManager; +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; +import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions; +import org.eclipse.xtext.scoping.IGlobalScopeProvider; +import org.eclipse.xtext.scoping.IScopeProvider; +import org.eclipse.xtext.scoping.IgnoreCaseLinking; +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; +import org.eclipse.xtext.serializer.ISerializer; +import org.eclipse.xtext.serializer.impl.Serializer; +import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; +import org.eclipse.xtext.service.SingletonBinding; + +/** + * Manual modifications go to {@link TqclRuntimeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractTqclRuntimeModule extends DefaultCommonTypesRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(Binder binder) { + properties = tryBindProperties(binder, "org/eclipse/triquetrum/commands/Tqcl.properties"); + super.configure(binder); + } + + public void configureLanguageName(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.triquetrum.commands.Tqcl"); + } + + public void configureFileExtensions(Binder binder) { + if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) + binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("tdcl"); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public ClassLoader bindClassLoaderToInstance() { + return getClass().getClassLoader(); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public Class bindIGrammarAccess() { + return TqclGrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISemanticSequencer() { + return TqclSemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return TqclSyntacticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISerializer() { + return Serializer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIParser() { + return TqclParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenToStringConverter() { + return AntlrTokenToStringConverter.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIAntlrTokenFileProvider() { + return TqclAntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalTqclLexer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenDefProvider() { + return AntlrTokenDefProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Provider provideInternalTqclLexer() { + return LexerProvider.create(InternalTqclLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureRuntimeLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerBindings.RUNTIME)) + .to(InternalTqclLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager=true) + public Class bindTqclValidator() { + return TqclValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIScopeProvider() { + return TqclScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIgnoreCaseLinking(Binder binder) { + binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIQualifiedNameProvider() { + return DefaultDeclarativeQualifiedNameProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIContainer$Manager() { + return StateBasedContainerManager.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIAllContainersState$Provider() { + return ResourceSetBasedAllContainersStateProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptions(Binder binder) { + binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptionsPersisted(Binder binder) { + binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public Class bindIGenerator2() { + return TqclGenerator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 + public Class bindIGlobalScopeProvider() { + return TypesAwareDefaultGlobalScopeProvider.class; + } + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/Tqcl.xtextbin b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/Tqcl.xtextbin new file mode 100644 index 0000000000000000000000000000000000000000..b745e957a8002fc7baf5a0bfda8708617acbf21d GIT binary patch literal 4813 zcma)AcYG5^7WUiGN|t2V7!yJZ5JEMH*N~8-IiA5d#0f3ffK$0e8ruSCWmYQ;T)$k) z_1=5UwOsGL-{pGA^?sM@z4yEC&8#HbG53r9@b1pM_kFKU@$I@imdP#2vWxPFOmrVa9FJP}gnqf~hmITgWxWOv4Y(*Qo~r36 ztd)E6703jIYR|~2d`aYLRb7bns*XeCET67-hS_`09QR?;XmoZ`Cl(a+STWGmYl?+} z4n`^`bxuM|Fpr(C0ZFxT| za1e^oS!bi0)+JrmK~#0qlx)3DpPj0N1vh!xFV(cOk}{NZoit_nk)t+#WQZt7j+5QD z_t?OJeftLYkBD{>jw@1>=%7?`PgtoII;k~#IEacRlOQ(@BTY8u^L)1l zSn6Wj;U?~aI_?FOauW*;kVh9%I=5es`;jgfsF^->H<1^S>x#wJ=q3EffnzD9W-9c% zVi_f8k3se#s|lUt!bVB#MmP8&f?ElyiRF}VRyfomHk_vlOs#sRR?#&`6?? z-VKJb+Yv2^m4@s5vXt1!G?!9aR-v}X1FlB5bxiwFE!3trlj+K&M#w9n)0b+L&1ID9 z7ziuXYNJ72Bi&=TJ?2JN#C}q;q1Q`UcN1J_zrKbhKra>c!ws>yUTT-KIafev3xrya zK&CLXTU=S6z8_|`qD%z_x77!?b9wGS5jp*?b1Usc^xQsb?--asjPeN4AwL+`u3OS$ z(N$bkJ|&Z3aeN}`=dW`_Qc}As6@TH6+{G_9Vt9aGR+HS#&tn)EB-e4e-K4yl754Bj zz~nXj!Z<@bd@X-5&UO64ID7d8IQ#f{jO2b6JHQ{k5Ie{(+feA{C$C3~fJ4YbJl;cc z*n}gV9pTx2Sa6trawjeRM36zXym;arS#sCaH> z#mE~>+E!CS-pI8lZ-UM$k~g#JEwSp+VyVE(*DTdrjjBAxDPL+*KBpj{@6UOXK6Rv2 zo;%o9j65C#AWnJqxSu3@11E*lTn=&!UbW@X@=@p)v07Tc#@V3boB#rMl;^X_9R^ z1)I8N*rbAjhGAiB7>uYIBO>;9Ey>#4^rxHjB&UqVnK?somTAw$q1aoQYJ}nemhpkj zP&8*@#e)pygJDIoT0;OyK4fl79@?}-J`90Cecn4E4`(ZGi=A)s#Lhn=HU+egG_;S3 zoqzP)l#gjr+S12gd3(J#9?Qy?l6)MLXBYhA*^W^be*#NgMe>POEg_#osaZ`UpKOeI z3U#>hsn*1&akLhh!Wjwz9nL6t?9=h;n5@*Wwxp&lk0hVYggs3C3>aqDPcEcqQqGmn zGVmTc{@Ji_3rju6cC#y=i*B|p{Jc3ldVcJYd_mp+7smd-Xb$NYH~fEz^&d=3_EMwF zH1cJ}>6f$9udq(PlAT^*oZh41bTO~O&_6rN_jc@yla&CQ1W%-#K9a9uwmZ1?jKVG~ zxhHj074p>pHpdeA8pHNlHs&UhujA(})+Um#XZ1Uw-Z^@8Eimgs%qip>fUsQ1H^MZ5 zU30boD(Ou?PRKXgC?@1v7c-QAC4`rdu{35a2#B>Bnn zb?&EF;*?3rCV3Z3Try*OK3a?>>WjLNpKj#!GbZ|~Fx%lqDhgP3(FJ`7KPi^4kbvsv6;tnNNy-H1Bs<(heYq-(~yy z-Hh2gs@TS?(DxwJ9E05V0h6=%_JC$m_5)rBerU7(BhL1G({k28D~I*r$L!-h@NwCU zJPZZH#w;5$A%D`y#80^bHe##%88o+${5dCq*CG7mFU*$yOW2d1iuZ79^RHM6sgl3O zT(+#s$92fZF=Od(3=-@Ac1}-z$DaH?_5?Qn0rHzz{ErZyUw540s*`@+V*ZK!x{HPW z93R(q;Df*KmiKIxf5FKvH9T@?X#XA||JrcwZ^r(=o2>nVO}g<6Pm zbg}r%mY{^X&@LS5I=<;dwFuc%ivij?VE=<4)RGu$DP!RR5KjPNnF-iMtg;*`si6S3 zC$O)GHCD1l+Vku<6fQ>SU9}34O%;tSsY_5XU+}aOmi_74jexrRCmm}ky*2zSDyhd?n2EaR$XRUIGL)a&V()8b*Hc>lIpdQ zv3m?($Lt=XHZkdDkY*Z-xKNkJtXD8=o98vAK)b~h;FUAT`L=_WQd_ya`bceK$IL$m zOa!)L8a>nasU1wZ( + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + $current); + } + ) + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + ruleArrayBrackets + { + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + this_XFunctionTypeRef_3=ruleXFunctionTypeRef + { + $current = $this_XFunctionTypeRef_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets returns [String current=null]: + { newCompositeNode(grammarAccess.getArrayBracketsRule()); } + iv_ruleArrayBrackets=ruleArrayBrackets + { $current=$iv_ruleArrayBrackets.current.getText(); } + EOF; + +// Rule ArrayBrackets +ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='[' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + kw=']' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); } + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef + { $current=$iv_ruleXFunctionTypeRef.current; } + EOF; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + lv_paramTypes_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + lv_paramTypes_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + )? + otherlv_5='=>' + { + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + lv_returnType_6_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + $current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference + { $current=$iv_ruleJvmParameterizedTypeReference.current; } + EOF; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_arguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_arguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + ( + ( + (( + ( + ) + '.' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + $current); + } + ) + otherlv_7='.' + { + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + ruleValidID + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_9='<' + { + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + lv_arguments_10_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + lv_arguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_13='>' + { + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + )? + )* + )? + ) +; + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); } + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference + { $current=$iv_ruleJvmArgumentTypeReference.current; } + EOF; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + this_JvmTypeReference_0=ruleJvmTypeReference + { + $current = $this_JvmTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference + { + $current = $this_JvmWildcardTypeReference_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); } + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference + { $current=$iv_ruleJvmWildcardTypeReference.current; } + EOF; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + $current); + } + ) + otherlv_1='?' + { + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + lv_constraints_2_0=ruleJvmUpperBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + lv_constraints_3_0=ruleJvmUpperBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + lv_constraints_4_0=ruleJvmLowerBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + lv_constraints_5_0=ruleJvmLowerBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + )? + ) +; + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundRule()); } + iv_ruleJvmUpperBound=ruleJvmUpperBound + { $current=$iv_ruleJvmUpperBound.current; } + EOF; + +// Rule JvmUpperBound +ruleJvmUpperBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='extends' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); } + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded + { $current=$iv_ruleJvmUpperBoundAnded.current; } + EOF; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundRule()); } + iv_ruleJvmLowerBound=ruleJvmLowerBound + { $current=$iv_ruleJvmLowerBound.current; } + EOF; + +// Rule JvmLowerBound +ruleJvmLowerBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='super' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); } + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded + { $current=$iv_ruleJvmLowerBoundAnded.current; } + EOF; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameRule()); } + iv_ruleQualifiedName=ruleQualifiedName + { $current=$iv_ruleQualifiedName.current.getText(); } + EOF; + +// Rule QualifiedName +ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + ( + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + this_ValidID_2=ruleValidID + { + $current.merge(this_ValidID_2); + } + { + afterParserOrEnumRuleCall(); + } + )* + ) +; + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); } + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard + { $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); } + EOF; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + this_QualifiedName_0=ruleQualifiedName + { + $current.merge(this_QualifiedName_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + ) +; + +// Entry rule entryRuleValidID +entryRuleValidID returns [String current=null]: + { newCompositeNode(grammarAccess.getValidIDRule()); } + iv_ruleValidID=ruleValidID + { $current=$iv_ruleValidID.current.getText(); } + EOF; + +// Rule ValidID +ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_ID_0=RULE_ID + { + $current.merge(this_ID_0); + } + { + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + } +; + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXImportDeclarationRule()); } + iv_ruleXImportDeclaration=ruleXImportDeclaration + { $current=$iv_ruleXImportDeclaration.current; } + EOF; + +// Rule XImportDeclaration +ruleXImportDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='import' + { + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + ( + ( + ( + ( + lv_static_1_0='static' + { + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "static", true, "static"); + } + ) + ) + ( + ( + lv_extension_2_0='extension' + { + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "extension", true, "extension"); + } + ) + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + ruleQualifiedNameInStaticImport + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + lv_wildcard_4_0='*' + { + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "wildcard", true, "*"); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + lv_memberName_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + )? + ) +; + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); } + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport + { $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); } + EOF; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + )+ +; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; + +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqcl.tokens b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqcl.tokens new file mode 100644 index 00000000..65400619 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqcl.tokens @@ -0,0 +1,54 @@ +'&'=27 +'('=18 +')'=20 +'*'=29 +','=19 +'.'=24 +';'=33 +'<'=22 +'='=13 +'=>'=21 +'>'=23 +'?'=25 +'['=16 +']'=17 +'as'=11 +'connect'=14 +'extends'=26 +'extension'=32 +'import'=30 +'insert'=10 +'static'=31 +'super'=28 +'to'=15 +'with'=12 +RULE_ANY_OTHER=9 +RULE_ID=5 +RULE_ML_COMMENT=6 +RULE_SL_COMMENT=7 +RULE_STRING=4 +RULE_WS=8 +T__10=10 +T__11=11 +T__12=12 +T__13=13 +T__14=14 +T__15=15 +T__16=16 +T__17=17 +T__18=18 +T__19=19 +T__20=20 +T__21=21 +T__22=22 +T__23=23 +T__24=24 +T__25=25 +T__26=26 +T__27=27 +T__28=28 +T__29=29 +T__30=30 +T__31=31 +T__32=32 +T__33=33 diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclLexer.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclLexer.java new file mode 100644 index 00000000..c96bce38 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclLexer.java @@ -0,0 +1,1473 @@ +package org.eclipse.triquetrum.commands.parser.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.parser.antlr.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalTqclLexer extends Lexer { + public static final int RULE_STRING=4; + public static final int RULE_SL_COMMENT=7; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__11=11; + public static final int T__33=33; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__10=10; + public static final int T__32=32; + public static final int RULE_ID=5; + public static final int RULE_WS=8; + public static final int RULE_ANY_OTHER=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=6; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + + // delegates + // delegators + + public InternalTqclLexer() {;} + public InternalTqclLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalTqclLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalTqcl.g"; } + + // $ANTLR start "T__10" + public final void mT__10() throws RecognitionException { + try { + int _type = T__10; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:11:7: ( 'insert' ) + // InternalTqcl.g:11:9: 'insert' + { + match("insert"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__10" + + // $ANTLR start "T__11" + public final void mT__11() throws RecognitionException { + try { + int _type = T__11; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:12:7: ( 'as' ) + // InternalTqcl.g:12:9: 'as' + { + match("as"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__11" + + // $ANTLR start "T__12" + public final void mT__12() throws RecognitionException { + try { + int _type = T__12; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:13:7: ( 'with' ) + // InternalTqcl.g:13:9: 'with' + { + match("with"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__12" + + // $ANTLR start "T__13" + public final void mT__13() throws RecognitionException { + try { + int _type = T__13; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:14:7: ( '=' ) + // InternalTqcl.g:14:9: '=' + { + match('='); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__13" + + // $ANTLR start "T__14" + public final void mT__14() throws RecognitionException { + try { + int _type = T__14; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:15:7: ( 'connect' ) + // InternalTqcl.g:15:9: 'connect' + { + match("connect"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__14" + + // $ANTLR start "T__15" + public final void mT__15() throws RecognitionException { + try { + int _type = T__15; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:16:7: ( 'to' ) + // InternalTqcl.g:16:9: 'to' + { + match("to"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__15" + + // $ANTLR start "T__16" + public final void mT__16() throws RecognitionException { + try { + int _type = T__16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:17:7: ( '[' ) + // InternalTqcl.g:17:9: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__16" + + // $ANTLR start "T__17" + public final void mT__17() throws RecognitionException { + try { + int _type = T__17; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:18:7: ( ']' ) + // InternalTqcl.g:18:9: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__17" + + // $ANTLR start "T__18" + public final void mT__18() throws RecognitionException { + try { + int _type = T__18; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:19:7: ( '(' ) + // InternalTqcl.g:19:9: '(' + { + match('('); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__18" + + // $ANTLR start "T__19" + public final void mT__19() throws RecognitionException { + try { + int _type = T__19; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:20:7: ( ',' ) + // InternalTqcl.g:20:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__19" + + // $ANTLR start "T__20" + public final void mT__20() throws RecognitionException { + try { + int _type = T__20; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:21:7: ( ')' ) + // InternalTqcl.g:21:9: ')' + { + match(')'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__20" + + // $ANTLR start "T__21" + public final void mT__21() throws RecognitionException { + try { + int _type = T__21; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:22:7: ( '=>' ) + // InternalTqcl.g:22:9: '=>' + { + match("=>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__21" + + // $ANTLR start "T__22" + public final void mT__22() throws RecognitionException { + try { + int _type = T__22; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:23:7: ( '<' ) + // InternalTqcl.g:23:9: '<' + { + match('<'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__22" + + // $ANTLR start "T__23" + public final void mT__23() throws RecognitionException { + try { + int _type = T__23; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:24:7: ( '>' ) + // InternalTqcl.g:24:9: '>' + { + match('>'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__23" + + // $ANTLR start "T__24" + public final void mT__24() throws RecognitionException { + try { + int _type = T__24; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:25:7: ( '.' ) + // InternalTqcl.g:25:9: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__24" + + // $ANTLR start "T__25" + public final void mT__25() throws RecognitionException { + try { + int _type = T__25; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:26:7: ( '?' ) + // InternalTqcl.g:26:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__25" + + // $ANTLR start "T__26" + public final void mT__26() throws RecognitionException { + try { + int _type = T__26; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:27:7: ( 'extends' ) + // InternalTqcl.g:27:9: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__26" + + // $ANTLR start "T__27" + public final void mT__27() throws RecognitionException { + try { + int _type = T__27; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:28:7: ( '&' ) + // InternalTqcl.g:28:9: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__27" + + // $ANTLR start "T__28" + public final void mT__28() throws RecognitionException { + try { + int _type = T__28; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:29:7: ( 'super' ) + // InternalTqcl.g:29:9: 'super' + { + match("super"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__28" + + // $ANTLR start "T__29" + public final void mT__29() throws RecognitionException { + try { + int _type = T__29; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:30:7: ( '*' ) + // InternalTqcl.g:30:9: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__29" + + // $ANTLR start "T__30" + public final void mT__30() throws RecognitionException { + try { + int _type = T__30; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:31:7: ( 'import' ) + // InternalTqcl.g:31:9: 'import' + { + match("import"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__30" + + // $ANTLR start "T__31" + public final void mT__31() throws RecognitionException { + try { + int _type = T__31; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:32:7: ( 'static' ) + // InternalTqcl.g:32:9: 'static' + { + match("static"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__31" + + // $ANTLR start "T__32" + public final void mT__32() throws RecognitionException { + try { + int _type = T__32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:33:7: ( 'extension' ) + // InternalTqcl.g:33:9: 'extension' + { + match("extension"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__32" + + // $ANTLR start "T__33" + public final void mT__33() throws RecognitionException { + try { + int _type = T__33; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:34:7: ( ';' ) + // InternalTqcl.g:34:9: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__33" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1375:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalTqcl.g:1375:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + { + // InternalTqcl.g:1375:11: ( '^' )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='^') ) { + alt1=1; + } + switch (alt1) { + case 1 : + // InternalTqcl.g:1375:11: '^' + { + match('^'); + + } + break; + + } + + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalTqcl.g:1375:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='$'||(LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='Z')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='z')) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalTqcl.g: + { + if ( input.LA(1)=='$'||(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') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1377:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalTqcl.g:1377:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + { + // InternalTqcl.g:1377:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='\"') ) { + alt7=1; + } + else if ( (LA7_0=='\'') ) { + alt7=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + switch (alt7) { + case 1 : + // InternalTqcl.g:1377:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? + { + match('\"'); + // InternalTqcl.g:1377:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop3: + do { + int alt3=3; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='\\') ) { + alt3=1; + } + else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { + alt3=2; + } + + + switch (alt3) { + case 1 : + // InternalTqcl.g:1377:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalTqcl.g:1377:28: ~ ( ( '\\\\' | '\"' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop3; + } + } while (true); + + // InternalTqcl.g:1377:44: ( '\"' )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='\"') ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalTqcl.g:1377:44: '\"' + { + match('\"'); + + } + break; + + } + + + } + break; + case 2 : + // InternalTqcl.g:1377:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? + { + match('\''); + // InternalTqcl.g:1377:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop5: + do { + int alt5=3; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='\\') ) { + alt5=1; + } + else if ( ((LA5_0>='\u0000' && LA5_0<='&')||(LA5_0>='(' && LA5_0<='[')||(LA5_0>=']' && LA5_0<='\uFFFF')) ) { + alt5=2; + } + + + switch (alt5) { + case 1 : + // InternalTqcl.g:1377:55: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalTqcl.g:1377:62: ~ ( ( '\\\\' | '\\'' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop5; + } + } while (true); + + // InternalTqcl.g:1377:79: ( '\\'' )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='\'') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalTqcl.g:1377:79: '\\'' + { + match('\''); + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_STRING" + + // $ANTLR start "RULE_ML_COMMENT" + public final void mRULE_ML_COMMENT() throws RecognitionException { + try { + int _type = RULE_ML_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1379:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalTqcl.g:1379:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalTqcl.g:1379:24: ( options {greedy=false; } : . )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='*') ) { + int LA8_1 = input.LA(2); + + if ( (LA8_1=='/') ) { + alt8=2; + } + else if ( ((LA8_1>='\u0000' && LA8_1<='.')||(LA8_1>='0' && LA8_1<='\uFFFF')) ) { + alt8=1; + } + + + } + else if ( ((LA8_0>='\u0000' && LA8_0<=')')||(LA8_0>='+' && LA8_0<='\uFFFF')) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalTqcl.g:1379:52: . + { + matchAny(); + + } + break; + + default : + break loop8; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1381:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalTqcl.g:1381:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + { + match("//"); + + // InternalTqcl.g:1381:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( ((LA9_0>='\u0000' && LA9_0<='\t')||(LA9_0>='\u000B' && LA9_0<='\f')||(LA9_0>='\u000E' && LA9_0<='\uFFFF')) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // InternalTqcl.g:1381:24: ~ ( ( '\\n' | '\\r' ) ) + { + 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') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop9; + } + } while (true); + + // InternalTqcl.g:1381:40: ( ( '\\r' )? '\\n' )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0=='\n'||LA11_0=='\r') ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalTqcl.g:1381:41: ( '\\r' )? '\\n' + { + // InternalTqcl.g:1381:41: ( '\\r' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='\r') ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalTqcl.g:1381:41: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1383:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalTqcl.g:1383:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalTqcl.g:1383:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt12=0; + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalTqcl.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt12 >= 1 ) break loop12; + EarlyExitException eee = + new EarlyExitException(12, input); + throw eee; + } + cnt12++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalTqcl.g:1385:16: ( . ) + // InternalTqcl.g:1385:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalTqcl.g:1:8: ( T__10 | 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 | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt13=30; + alt13 = dfa13.predict(input); + switch (alt13) { + case 1 : + // InternalTqcl.g:1:10: T__10 + { + mT__10(); + + } + break; + case 2 : + // InternalTqcl.g:1:16: T__11 + { + mT__11(); + + } + break; + case 3 : + // InternalTqcl.g:1:22: T__12 + { + mT__12(); + + } + break; + case 4 : + // InternalTqcl.g:1:28: T__13 + { + mT__13(); + + } + break; + case 5 : + // InternalTqcl.g:1:34: T__14 + { + mT__14(); + + } + break; + case 6 : + // InternalTqcl.g:1:40: T__15 + { + mT__15(); + + } + break; + case 7 : + // InternalTqcl.g:1:46: T__16 + { + mT__16(); + + } + break; + case 8 : + // InternalTqcl.g:1:52: T__17 + { + mT__17(); + + } + break; + case 9 : + // InternalTqcl.g:1:58: T__18 + { + mT__18(); + + } + break; + case 10 : + // InternalTqcl.g:1:64: T__19 + { + mT__19(); + + } + break; + case 11 : + // InternalTqcl.g:1:70: T__20 + { + mT__20(); + + } + break; + case 12 : + // InternalTqcl.g:1:76: T__21 + { + mT__21(); + + } + break; + case 13 : + // InternalTqcl.g:1:82: T__22 + { + mT__22(); + + } + break; + case 14 : + // InternalTqcl.g:1:88: T__23 + { + mT__23(); + + } + break; + case 15 : + // InternalTqcl.g:1:94: T__24 + { + mT__24(); + + } + break; + case 16 : + // InternalTqcl.g:1:100: T__25 + { + mT__25(); + + } + break; + case 17 : + // InternalTqcl.g:1:106: T__26 + { + mT__26(); + + } + break; + case 18 : + // InternalTqcl.g:1:112: T__27 + { + mT__27(); + + } + break; + case 19 : + // InternalTqcl.g:1:118: T__28 + { + mT__28(); + + } + break; + case 20 : + // InternalTqcl.g:1:124: T__29 + { + mT__29(); + + } + break; + case 21 : + // InternalTqcl.g:1:130: T__30 + { + mT__30(); + + } + break; + case 22 : + // InternalTqcl.g:1:136: T__31 + { + mT__31(); + + } + break; + case 23 : + // InternalTqcl.g:1:142: T__32 + { + mT__32(); + + } + break; + case 24 : + // InternalTqcl.g:1:148: T__33 + { + mT__33(); + + } + break; + case 25 : + // InternalTqcl.g:1:154: RULE_ID + { + mRULE_ID(); + + } + break; + case 26 : + // InternalTqcl.g:1:162: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 27 : + // InternalTqcl.g:1:174: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 28 : + // InternalTqcl.g:1:190: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 29 : + // InternalTqcl.g:1:206: RULE_WS + { + mRULE_WS(); + + } + break; + case 30 : + // InternalTqcl.g:1:214: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA13 dfa13 = new DFA13(this); + static final String DFA13_eotS = + "\1\uffff\3\36\1\42\2\36\11\uffff\1\36\1\uffff\1\36\2\uffff\1\33\3\uffff\1\33\2\uffff\2\36\1\uffff\1\72\1\36\2\uffff\1\36\1\75\11\uffff\1\36\1\uffff\2\36\6\uffff\2\36\1\uffff\2\36\1\uffff\5\36\1\112\6\36\1\uffff\2\36\1\124\1\36\1\126\1\127\3\36\1\uffff\1\133\2\uffff\1\134\1\135\1\36\3\uffff\1\36\1\140\1\uffff"; + static final String DFA13_eofS = + "\141\uffff"; + static final String DFA13_minS = + "\1\0\1\155\1\163\1\151\1\76\2\157\11\uffff\1\170\1\uffff\1\164\2\uffff\1\44\3\uffff\1\52\2\uffff\1\163\1\160\1\uffff\1\44\1\164\2\uffff\1\156\1\44\11\uffff\1\164\1\uffff\1\160\1\141\6\uffff\1\145\1\157\1\uffff\1\150\1\156\1\uffff\2\145\1\164\2\162\1\44\1\145\1\156\1\162\1\151\2\164\1\uffff\1\143\1\144\1\44\1\143\2\44\1\164\1\163\1\151\1\uffff\1\44\2\uffff\2\44\1\157\3\uffff\1\156\1\44\1\uffff"; + static final String DFA13_maxS = + "\1\uffff\1\156\1\163\1\151\1\76\2\157\11\uffff\1\170\1\uffff\1\165\2\uffff\1\172\3\uffff\1\57\2\uffff\1\163\1\160\1\uffff\1\172\1\164\2\uffff\1\156\1\172\11\uffff\1\164\1\uffff\1\160\1\141\6\uffff\1\145\1\157\1\uffff\1\150\1\156\1\uffff\2\145\1\164\2\162\1\172\1\145\1\156\1\162\1\151\2\164\1\uffff\1\143\1\163\1\172\1\143\2\172\1\164\1\163\1\151\1\uffff\1\172\2\uffff\2\172\1\157\3\uffff\1\156\1\172\1\uffff"; + static final String DFA13_acceptS = + "\7\uffff\1\7\1\10\1\11\1\12\1\13\1\15\1\16\1\17\1\20\1\uffff\1\22\1\uffff\1\24\1\30\1\uffff\1\31\2\32\1\uffff\1\35\1\36\2\uffff\1\31\2\uffff\1\14\1\4\2\uffff\1\7\1\10\1\11\1\12\1\13\1\15\1\16\1\17\1\20\1\uffff\1\22\2\uffff\1\24\1\30\1\32\1\33\1\34\1\35\2\uffff\1\2\2\uffff\1\6\14\uffff\1\3\11\uffff\1\23\1\uffff\1\1\1\25\3\uffff\1\26\1\5\1\21\2\uffff\1\27"; + static final String DFA13_specialS = + "\1\0\140\uffff}>"; + static final String[] DFA13_transitionS = { + "\11\33\2\32\2\33\1\32\22\33\1\32\1\33\1\27\1\33\1\26\1\33\1\21\1\30\1\11\1\13\1\23\1\33\1\12\1\33\1\16\1\31\13\33\1\24\1\14\1\4\1\15\1\17\1\33\32\26\1\7\1\33\1\10\1\25\1\26\1\33\1\2\1\26\1\5\1\26\1\20\3\26\1\1\11\26\1\22\1\6\2\26\1\3\3\26\uff85\33", + "\1\35\1\34", + "\1\37", + "\1\40", + "\1\41", + "\1\43", + "\1\44", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\56", + "", + "\1\61\1\60", + "", + "", + "\1\36\34\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "", + "", + "", + "\1\65\4\uffff\1\66", + "", + "", + "\1\70", + "\1\71", + "", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\73", + "", + "", + "\1\74", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\76", + "", + "\1\77", + "\1\100", + "", + "", + "", + "", + "", + "", + "\1\101", + "\1\102", + "", + "\1\103", + "\1\104", + "", + "\1\105", + "\1\106", + "\1\107", + "\1\110", + "\1\111", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\113", + "\1\114", + "\1\115", + "\1\116", + "\1\117", + "\1\120", + "", + "\1\121", + "\1\122\16\uffff\1\123", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\125", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\130", + "\1\131", + "\1\132", + "", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "", + "", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "\1\136", + "", + "", + "", + "\1\137", + "\1\36\13\uffff\12\36\7\uffff\32\36\4\uffff\1\36\1\uffff\32\36", + "" + }; + + static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS); + static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS); + static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS); + static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS); + static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS); + static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS); + static final short[][] DFA13_transition; + + static { + int numStates = DFA13_transitionS.length; + DFA13_transition = new short[numStates][]; + for (int i=0; i') ) {s = 13;} + + else if ( (LA13_0=='.') ) {s = 14;} + + else if ( (LA13_0=='?') ) {s = 15;} + + else if ( (LA13_0=='e') ) {s = 16;} + + else if ( (LA13_0=='&') ) {s = 17;} + + else if ( (LA13_0=='s') ) {s = 18;} + + else if ( (LA13_0=='*') ) {s = 19;} + + else if ( (LA13_0==';') ) {s = 20;} + + else if ( (LA13_0=='^') ) {s = 21;} + + else if ( (LA13_0=='$'||(LA13_0>='A' && LA13_0<='Z')||LA13_0=='_'||LA13_0=='b'||LA13_0=='d'||(LA13_0>='f' && LA13_0<='h')||(LA13_0>='j' && LA13_0<='r')||(LA13_0>='u' && LA13_0<='v')||(LA13_0>='x' && LA13_0<='z')) ) {s = 22;} + + else if ( (LA13_0=='\"') ) {s = 23;} + + else if ( (LA13_0=='\'') ) {s = 24;} + + else if ( (LA13_0=='/') ) {s = 25;} + + else if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) {s = 26;} + + else if ( ((LA13_0>='\u0000' && LA13_0<='\b')||(LA13_0>='\u000B' && LA13_0<='\f')||(LA13_0>='\u000E' && LA13_0<='\u001F')||LA13_0=='!'||LA13_0=='#'||LA13_0=='%'||LA13_0=='+'||LA13_0=='-'||(LA13_0>='0' && LA13_0<=':')||LA13_0=='@'||LA13_0=='\\'||LA13_0=='`'||(LA13_0>='{' && LA13_0<='\uFFFF')) ) {s = 27;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 13, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclParser.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclParser.java new file mode 100644 index 00000000..3ed60a76 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/parser/antlr/internal/InternalTqclParser.java @@ -0,0 +1,4213 @@ +package org.eclipse.triquetrum.commands.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import org.eclipse.triquetrum.commands.services.TqclGrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +@SuppressWarnings("all") +public class InternalTqclParser extends AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "RULE_STRING", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'insert'", "'as'", "'with'", "'='", "'connect'", "'to'", "'['", "']'", "'('", "','", "')'", "'=>'", "'<'", "'>'", "'.'", "'?'", "'extends'", "'&'", "'super'", "'*'", "'import'", "'static'", "'extension'", "';'" + }; + public static final int RULE_STRING=4; + public static final int RULE_SL_COMMENT=7; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__11=11; + public static final int T__33=33; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__10=10; + public static final int T__32=32; + public static final int RULE_ID=5; + public static final int RULE_WS=8; + public static final int RULE_ANY_OTHER=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=6; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + + // delegates + // delegators + + + public InternalTqclParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalTqclParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalTqclParser.tokenNames; } + public String getGrammarFileName() { return "InternalTqcl.g"; } + + + + private TqclGrammarAccess grammarAccess; + + public InternalTqclParser(TokenStream input, TqclGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "TriquetrumScript"; + } + + @Override + protected TqclGrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRuleTriquetrumScript" + // InternalTqcl.g:64:1: entryRuleTriquetrumScript returns [EObject current=null] : iv_ruleTriquetrumScript= ruleTriquetrumScript EOF ; + public final EObject entryRuleTriquetrumScript() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTriquetrumScript = null; + + + try { + // InternalTqcl.g:64:57: (iv_ruleTriquetrumScript= ruleTriquetrumScript EOF ) + // InternalTqcl.g:65:2: iv_ruleTriquetrumScript= ruleTriquetrumScript EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getTriquetrumScriptRule()); + } + pushFollow(FOLLOW_1); + iv_ruleTriquetrumScript=ruleTriquetrumScript(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleTriquetrumScript; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTriquetrumScript" + + + // $ANTLR start "ruleTriquetrumScript" + // InternalTqcl.g:71:1: ruleTriquetrumScript returns [EObject current=null] : ( (lv_commands_0_0= ruleCommand ) )* ; + public final EObject ruleTriquetrumScript() throws RecognitionException { + EObject current = null; + + EObject lv_commands_0_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:77:2: ( ( (lv_commands_0_0= ruleCommand ) )* ) + // InternalTqcl.g:78:2: ( (lv_commands_0_0= ruleCommand ) )* + { + // InternalTqcl.g:78:2: ( (lv_commands_0_0= ruleCommand ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==10||LA1_0==14) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalTqcl.g:79:3: (lv_commands_0_0= ruleCommand ) + { + // InternalTqcl.g:79:3: (lv_commands_0_0= ruleCommand ) + // InternalTqcl.g:80:4: lv_commands_0_0= ruleCommand + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getTriquetrumScriptAccess().getCommandsCommandParserRuleCall_0()); + + } + pushFollow(FOLLOW_3); + lv_commands_0_0=ruleCommand(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTriquetrumScriptRule()); + } + add( + current, + "commands", + lv_commands_0_0, + "org.eclipse.triquetrum.commands.Tqcl.Command"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop1; + } + } while (true); + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTriquetrumScript" + + + // $ANTLR start "entryRuleCommand" + // InternalTqcl.g:100:1: entryRuleCommand returns [EObject current=null] : iv_ruleCommand= ruleCommand EOF ; + public final EObject entryRuleCommand() throws RecognitionException { + EObject current = null; + + EObject iv_ruleCommand = null; + + + try { + // InternalTqcl.g:100:48: (iv_ruleCommand= ruleCommand EOF ) + // InternalTqcl.g:101:2: iv_ruleCommand= ruleCommand EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getCommandRule()); + } + pushFollow(FOLLOW_1); + iv_ruleCommand=ruleCommand(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleCommand; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleCommand" + + + // $ANTLR start "ruleCommand" + // InternalTqcl.g:107:1: ruleCommand returns [EObject current=null] : (this_Insert_0= ruleInsert | this_Connect_1= ruleConnect ) ; + public final EObject ruleCommand() throws RecognitionException { + EObject current = null; + + EObject this_Insert_0 = null; + + EObject this_Connect_1 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:113:2: ( (this_Insert_0= ruleInsert | this_Connect_1= ruleConnect ) ) + // InternalTqcl.g:114:2: (this_Insert_0= ruleInsert | this_Connect_1= ruleConnect ) + { + // InternalTqcl.g:114:2: (this_Insert_0= ruleInsert | this_Connect_1= ruleConnect ) + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==10) ) { + alt2=1; + } + else if ( (LA2_0==14) ) { + alt2=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + switch (alt2) { + case 1 : + // InternalTqcl.g:115:3: this_Insert_0= ruleInsert + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getCommandAccess().getInsertParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_Insert_0=ruleInsert(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_Insert_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalTqcl.g:124:3: this_Connect_1= ruleConnect + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getCommandAccess().getConnectParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_Connect_1=ruleConnect(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_Connect_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleCommand" + + + // $ANTLR start "entryRuleInsert" + // InternalTqcl.g:136:1: entryRuleInsert returns [EObject current=null] : iv_ruleInsert= ruleInsert EOF ; + public final EObject entryRuleInsert() throws RecognitionException { + EObject current = null; + + EObject iv_ruleInsert = null; + + + try { + // InternalTqcl.g:136:47: (iv_ruleInsert= ruleInsert EOF ) + // InternalTqcl.g:137:2: iv_ruleInsert= ruleInsert EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getInsertRule()); + } + pushFollow(FOLLOW_1); + iv_ruleInsert=ruleInsert(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleInsert; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleInsert" + + + // $ANTLR start "ruleInsert" + // InternalTqcl.g:143:1: ruleInsert returns [EObject current=null] : (otherlv_0= 'insert' ( (lv_obj_1_0= ruleQualifiedName ) ) (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? ) ; + public final EObject ruleInsert() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + AntlrDatatypeRuleToken lv_obj_1_0 = null; + + EObject lv_alias_3_0 = null; + + EObject lv_parameters_5_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:149:2: ( (otherlv_0= 'insert' ( (lv_obj_1_0= ruleQualifiedName ) ) (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? ) ) + // InternalTqcl.g:150:2: (otherlv_0= 'insert' ( (lv_obj_1_0= ruleQualifiedName ) ) (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? ) + { + // InternalTqcl.g:150:2: (otherlv_0= 'insert' ( (lv_obj_1_0= ruleQualifiedName ) ) (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? ) + // InternalTqcl.g:151:3: otherlv_0= 'insert' ( (lv_obj_1_0= ruleQualifiedName ) ) (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? + { + otherlv_0=(Token)match(input,10,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getInsertAccess().getInsertKeyword_0()); + + } + // InternalTqcl.g:155:3: ( (lv_obj_1_0= ruleQualifiedName ) ) + // InternalTqcl.g:156:4: (lv_obj_1_0= ruleQualifiedName ) + { + // InternalTqcl.g:156:4: (lv_obj_1_0= ruleQualifiedName ) + // InternalTqcl.g:157:5: lv_obj_1_0= ruleQualifiedName + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getInsertAccess().getObjQualifiedNameParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_5); + lv_obj_1_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getInsertRule()); + } + set( + current, + "obj", + lv_obj_1_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedName"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:174:3: (otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==11) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // InternalTqcl.g:175:4: otherlv_2= 'as' ( (lv_alias_3_0= ruleNamedObj ) ) + { + otherlv_2=(Token)match(input,11,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getInsertAccess().getAsKeyword_2_0()); + + } + // InternalTqcl.g:179:4: ( (lv_alias_3_0= ruleNamedObj ) ) + // InternalTqcl.g:180:5: (lv_alias_3_0= ruleNamedObj ) + { + // InternalTqcl.g:180:5: (lv_alias_3_0= ruleNamedObj ) + // InternalTqcl.g:181:6: lv_alias_3_0= ruleNamedObj + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getInsertAccess().getAliasNamedObjParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_6); + lv_alias_3_0=ruleNamedObj(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getInsertRule()); + } + set( + current, + "alias", + lv_alias_3_0, + "org.eclipse.triquetrum.commands.Tqcl.NamedObj"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalTqcl.g:199:3: (otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* )? + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==12) ) { + alt5=1; + } + switch (alt5) { + case 1 : + // InternalTqcl.g:200:4: otherlv_4= 'with' ( (lv_parameters_5_0= ruleParameter ) )* + { + otherlv_4=(Token)match(input,12,FOLLOW_7); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getInsertAccess().getWithKeyword_3_0()); + + } + // InternalTqcl.g:204:4: ( (lv_parameters_5_0= ruleParameter ) )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==RULE_ID) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalTqcl.g:205:5: (lv_parameters_5_0= ruleParameter ) + { + // InternalTqcl.g:205:5: (lv_parameters_5_0= ruleParameter ) + // InternalTqcl.g:206:6: lv_parameters_5_0= ruleParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getInsertAccess().getParametersParameterParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_7); + lv_parameters_5_0=ruleParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getInsertRule()); + } + add( + current, + "parameters", + lv_parameters_5_0, + "org.eclipse.triquetrum.commands.Tqcl.Parameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop4; + } + } while (true); + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleInsert" + + + // $ANTLR start "entryRuleParameter" + // InternalTqcl.g:228:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + public final EObject entryRuleParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameter = null; + + + try { + // InternalTqcl.g:228:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalTqcl.g:229:2: iv_ruleParameter= ruleParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleParameter=ruleParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalTqcl.g:235:1: ruleParameter returns [EObject current=null] : ( ( (lv_name_0_0= ruleQualifiedName ) ) otherlv_1= '=' ( (lv_value_2_0= RULE_STRING ) ) ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_value_2_0=null; + AntlrDatatypeRuleToken lv_name_0_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:241:2: ( ( ( (lv_name_0_0= ruleQualifiedName ) ) otherlv_1= '=' ( (lv_value_2_0= RULE_STRING ) ) ) ) + // InternalTqcl.g:242:2: ( ( (lv_name_0_0= ruleQualifiedName ) ) otherlv_1= '=' ( (lv_value_2_0= RULE_STRING ) ) ) + { + // InternalTqcl.g:242:2: ( ( (lv_name_0_0= ruleQualifiedName ) ) otherlv_1= '=' ( (lv_value_2_0= RULE_STRING ) ) ) + // InternalTqcl.g:243:3: ( (lv_name_0_0= ruleQualifiedName ) ) otherlv_1= '=' ( (lv_value_2_0= RULE_STRING ) ) + { + // InternalTqcl.g:243:3: ( (lv_name_0_0= ruleQualifiedName ) ) + // InternalTqcl.g:244:4: (lv_name_0_0= ruleQualifiedName ) + { + // InternalTqcl.g:244:4: (lv_name_0_0= ruleQualifiedName ) + // InternalTqcl.g:245:5: lv_name_0_0= ruleQualifiedName + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getParameterAccess().getNameQualifiedNameParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_8); + lv_name_0_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "name", + lv_name_0_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedName"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_1=(Token)match(input,13,FOLLOW_9); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getEqualsSignKeyword_1()); + + } + // InternalTqcl.g:266:3: ( (lv_value_2_0= RULE_STRING ) ) + // InternalTqcl.g:267:4: (lv_value_2_0= RULE_STRING ) + { + // InternalTqcl.g:267:4: (lv_value_2_0= RULE_STRING ) + // InternalTqcl.g:268:5: lv_value_2_0= RULE_STRING + { + lv_value_2_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_value_2_0, grammarAccess.getParameterAccess().getValueSTRINGTerminalRuleCall_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getParameterRule()); + } + setWithLastConsumed( + current, + "value", + lv_value_2_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleNamedObj" + // InternalTqcl.g:288:1: entryRuleNamedObj returns [EObject current=null] : iv_ruleNamedObj= ruleNamedObj EOF ; + public final EObject entryRuleNamedObj() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNamedObj = null; + + + try { + // InternalTqcl.g:288:49: (iv_ruleNamedObj= ruleNamedObj EOF ) + // InternalTqcl.g:289:2: iv_ruleNamedObj= ruleNamedObj EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getNamedObjRule()); + } + pushFollow(FOLLOW_1); + iv_ruleNamedObj=ruleNamedObj(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleNamedObj; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNamedObj" + + + // $ANTLR start "ruleNamedObj" + // InternalTqcl.g:295:1: ruleNamedObj returns [EObject current=null] : ( (lv_name_0_0= ruleQualifiedName ) ) ; + public final EObject ruleNamedObj() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_name_0_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:301:2: ( ( (lv_name_0_0= ruleQualifiedName ) ) ) + // InternalTqcl.g:302:2: ( (lv_name_0_0= ruleQualifiedName ) ) + { + // InternalTqcl.g:302:2: ( (lv_name_0_0= ruleQualifiedName ) ) + // InternalTqcl.g:303:3: (lv_name_0_0= ruleQualifiedName ) + { + // InternalTqcl.g:303:3: (lv_name_0_0= ruleQualifiedName ) + // InternalTqcl.g:304:4: lv_name_0_0= ruleQualifiedName + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getNamedObjAccess().getNameQualifiedNameParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + lv_name_0_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNamedObjRule()); + } + set( + current, + "name", + lv_name_0_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedName"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNamedObj" + + + // $ANTLR start "entryRuleConnect" + // InternalTqcl.g:324:1: entryRuleConnect returns [EObject current=null] : iv_ruleConnect= ruleConnect EOF ; + public final EObject entryRuleConnect() throws RecognitionException { + EObject current = null; + + EObject iv_ruleConnect = null; + + + try { + // InternalTqcl.g:324:48: (iv_ruleConnect= ruleConnect EOF ) + // InternalTqcl.g:325:2: iv_ruleConnect= ruleConnect EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getConnectRule()); + } + pushFollow(FOLLOW_1); + iv_ruleConnect=ruleConnect(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleConnect; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleConnect" + + + // $ANTLR start "ruleConnect" + // InternalTqcl.g:331:1: ruleConnect returns [EObject current=null] : (otherlv_0= 'connect' ( (lv_from_1_0= ruleNamedObj ) ) otherlv_2= 'to' ( (lv_to_3_0= ruleNamedObj ) ) ) ; + public final EObject ruleConnect() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + EObject lv_from_1_0 = null; + + EObject lv_to_3_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:337:2: ( (otherlv_0= 'connect' ( (lv_from_1_0= ruleNamedObj ) ) otherlv_2= 'to' ( (lv_to_3_0= ruleNamedObj ) ) ) ) + // InternalTqcl.g:338:2: (otherlv_0= 'connect' ( (lv_from_1_0= ruleNamedObj ) ) otherlv_2= 'to' ( (lv_to_3_0= ruleNamedObj ) ) ) + { + // InternalTqcl.g:338:2: (otherlv_0= 'connect' ( (lv_from_1_0= ruleNamedObj ) ) otherlv_2= 'to' ( (lv_to_3_0= ruleNamedObj ) ) ) + // InternalTqcl.g:339:3: otherlv_0= 'connect' ( (lv_from_1_0= ruleNamedObj ) ) otherlv_2= 'to' ( (lv_to_3_0= ruleNamedObj ) ) + { + otherlv_0=(Token)match(input,14,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getConnectAccess().getConnectKeyword_0()); + + } + // InternalTqcl.g:343:3: ( (lv_from_1_0= ruleNamedObj ) ) + // InternalTqcl.g:344:4: (lv_from_1_0= ruleNamedObj ) + { + // InternalTqcl.g:344:4: (lv_from_1_0= ruleNamedObj ) + // InternalTqcl.g:345:5: lv_from_1_0= ruleNamedObj + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getConnectAccess().getFromNamedObjParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_10); + lv_from_1_0=ruleNamedObj(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConnectRule()); + } + set( + current, + "from", + lv_from_1_0, + "org.eclipse.triquetrum.commands.Tqcl.NamedObj"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_2=(Token)match(input,15,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getConnectAccess().getToKeyword_2()); + + } + // InternalTqcl.g:366:3: ( (lv_to_3_0= ruleNamedObj ) ) + // InternalTqcl.g:367:4: (lv_to_3_0= ruleNamedObj ) + { + // InternalTqcl.g:367:4: (lv_to_3_0= ruleNamedObj ) + // InternalTqcl.g:368:5: lv_to_3_0= ruleNamedObj + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getConnectAccess().getToNamedObjParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_to_3_0=ruleNamedObj(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConnectRule()); + } + set( + current, + "to", + lv_to_3_0, + "org.eclipse.triquetrum.commands.Tqcl.NamedObj"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleConnect" + + + // $ANTLR start "entryRuleJvmTypeReference" + // InternalTqcl.g:389:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ; + public final EObject entryRuleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmTypeReference = null; + + + try { + // InternalTqcl.g:389:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ) + // InternalTqcl.g:390:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmTypeReference=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmTypeReference" + + + // $ANTLR start "ruleJvmTypeReference" + // InternalTqcl.g:396:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ; + public final EObject ruleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmParameterizedTypeReference_0 = null; + + EObject this_XFunctionTypeRef_3 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:402:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ) + // InternalTqcl.g:403:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + { + // InternalTqcl.g:403:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==RULE_ID) ) { + alt7=1; + } + else if ( (LA7_0==18||LA7_0==21) ) { + alt7=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + switch (alt7) { + case 1 : + // InternalTqcl.g:404:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + { + // InternalTqcl.g:404:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + // InternalTqcl.g:405:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_11); + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmParameterizedTypeReference_0; + afterParserOrEnumRuleCall(); + + } + // InternalTqcl.g:413:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==16) && (synpred1_InternalTqcl())) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalTqcl.g:414:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) + { + // InternalTqcl.g:420:5: ( () ruleArrayBrackets ) + // InternalTqcl.g:421:6: () ruleArrayBrackets + { + // InternalTqcl.g:421:6: () + // InternalTqcl.g:422:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + current); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + + } + pushFollow(FOLLOW_11); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop6; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalTqcl.g:439:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XFunctionTypeRef_3=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFunctionTypeRef_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmTypeReference" + + + // $ANTLR start "entryRuleArrayBrackets" + // InternalTqcl.g:451:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ; + public final String entryRuleArrayBrackets() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleArrayBrackets = null; + + + try { + // InternalTqcl.g:451:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF ) + // InternalTqcl.g:452:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + iv_ruleArrayBrackets=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleArrayBrackets.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayBrackets" + + + // $ANTLR start "ruleArrayBrackets" + // InternalTqcl.g:458:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ; + public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalTqcl.g:464:2: ( (kw= '[' kw= ']' ) ) + // InternalTqcl.g:465:2: (kw= '[' kw= ']' ) + { + // InternalTqcl.g:465:2: (kw= '[' kw= ']' ) + // InternalTqcl.g:466:3: kw= '[' kw= ']' + { + kw=(Token)match(input,16,FOLLOW_12); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + + } + kw=(Token)match(input,17,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayBrackets" + + + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalTqcl.g:480:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ; + public final EObject entryRuleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFunctionTypeRef = null; + + + try { + // InternalTqcl.g:480:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ) + // InternalTqcl.g:481:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFunctionTypeRef; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFunctionTypeRef" + + + // $ANTLR start "ruleXFunctionTypeRef" + // InternalTqcl.g:487:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_5=null; + EObject lv_paramTypes_1_0 = null; + + EObject lv_paramTypes_3_0 = null; + + EObject lv_returnType_6_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:493:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ) + // InternalTqcl.g:494:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + { + // InternalTqcl.g:494:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + // InternalTqcl.g:495:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + { + // InternalTqcl.g:495:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==18) ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalTqcl.g:496:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' + { + otherlv_0=(Token)match(input,18,FOLLOW_13); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + + } + // InternalTqcl.g:500:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==RULE_ID||LA9_0==18||LA9_0==21) ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalTqcl.g:501:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + { + // InternalTqcl.g:501:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:502:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:502:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + // InternalTqcl.g:503:7: lv_paramTypes_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + + } + pushFollow(FOLLOW_14); + lv_paramTypes_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:520:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==19) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalTqcl.g:521:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + { + otherlv_2=(Token)match(input,19,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + + } + // InternalTqcl.g:525:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:526:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:526:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + // InternalTqcl.g:527:8: lv_paramTypes_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + + } + pushFollow(FOLLOW_14); + lv_paramTypes_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop8; + } + } while (true); + + + } + break; + + } + + otherlv_4=(Token)match(input,20,FOLLOW_16); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + + } + + } + break; + + } + + otherlv_5=(Token)match(input,21,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + + } + // InternalTqcl.g:555:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:556:4: (lv_returnType_6_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:556:4: (lv_returnType_6_0= ruleJvmTypeReference ) + // InternalTqcl.g:557:5: lv_returnType_6_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_returnType_6_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFunctionTypeRef" + + + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalTqcl.g:578:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ; + public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmParameterizedTypeReference = null; + + + try { + // InternalTqcl.g:578:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ) + // InternalTqcl.g:579:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmParameterizedTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmParameterizedTypeReference" + + + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalTqcl.g:585:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ; + public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_arguments_2_0 = null; + + EObject lv_arguments_4_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:591:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ) + // InternalTqcl.g:592:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + { + // InternalTqcl.g:592:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + // InternalTqcl.g:593:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + { + // InternalTqcl.g:593:3: ( ( ruleQualifiedName ) ) + // InternalTqcl.g:594:4: ( ruleQualifiedName ) + { + // InternalTqcl.g:594:4: ( ruleQualifiedName ) + // InternalTqcl.g:595:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + + } + pushFollow(FOLLOW_17); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:609:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==22) && (synpred2_InternalTqcl())) { + alt15=1; + } + switch (alt15) { + case 1 : + // InternalTqcl.g:610:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + { + // InternalTqcl.g:610:4: ( ( '<' )=>otherlv_1= '<' ) + // InternalTqcl.g:611:5: ( '<' )=>otherlv_1= '<' + { + otherlv_1=(Token)match(input,22,FOLLOW_18); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + + } + + } + + // InternalTqcl.g:617:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalTqcl.g:618:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalTqcl.g:618:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + // InternalTqcl.g:619:6: lv_arguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_19); + lv_arguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:636:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==19) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // InternalTqcl.g:637:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,19,FOLLOW_18); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + + } + // InternalTqcl.g:641:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalTqcl.g:642:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalTqcl.g:642:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + // InternalTqcl.g:643:7: lv_arguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_19); + lv_arguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop11; + } + } while (true); + + otherlv_5=(Token)match(input,23,FOLLOW_20); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + + } + // InternalTqcl.g:665:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + loop14: + do { + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==24) && (synpred3_InternalTqcl())) { + alt14=1; + } + + + switch (alt14) { + case 1 : + // InternalTqcl.g:666:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + { + // InternalTqcl.g:666:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) + // InternalTqcl.g:667:6: ( ( () '.' ) )=> ( () otherlv_7= '.' ) + { + // InternalTqcl.g:673:6: ( () otherlv_7= '.' ) + // InternalTqcl.g:674:7: () otherlv_7= '.' + { + // InternalTqcl.g:674:7: () + // InternalTqcl.g:675:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + current); + + } + + } + + otherlv_7=(Token)match(input,24,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + + } + + } + + + } + + // InternalTqcl.g:687:5: ( ( ruleValidID ) ) + // InternalTqcl.g:688:6: ( ruleValidID ) + { + // InternalTqcl.g:688:6: ( ruleValidID ) + // InternalTqcl.g:689:7: ruleValidID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + + } + pushFollow(FOLLOW_21); + ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:703:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==22) && (synpred4_InternalTqcl())) { + alt13=1; + } + switch (alt13) { + case 1 : + // InternalTqcl.g:704:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' + { + // InternalTqcl.g:704:6: ( ( '<' )=>otherlv_9= '<' ) + // InternalTqcl.g:705:7: ( '<' )=>otherlv_9= '<' + { + otherlv_9=(Token)match(input,22,FOLLOW_18); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + + } + + } + + // InternalTqcl.g:711:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) + // InternalTqcl.g:712:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + { + // InternalTqcl.g:712:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + // InternalTqcl.g:713:8: lv_arguments_10_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + + } + pushFollow(FOLLOW_19); + lv_arguments_10_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:730:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==19) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalTqcl.g:731:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_11=(Token)match(input,19,FOLLOW_18); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + + } + // InternalTqcl.g:735:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalTqcl.g:736:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalTqcl.g:736:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + // InternalTqcl.g:737:9: lv_arguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + + } + pushFollow(FOLLOW_19); + lv_arguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop12; + } + } while (true); + + otherlv_13=(Token)match(input,23,FOLLOW_20); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + + } + + } + break; + + } + + + } + break; + + default : + break loop14; + } + } while (true); + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmParameterizedTypeReference" + + + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalTqcl.g:766:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ; + public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmArgumentTypeReference = null; + + + try { + // InternalTqcl.g:766:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ) + // InternalTqcl.g:767:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmArgumentTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmArgumentTypeReference" + + + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalTqcl.g:773:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ; + public final EObject ruleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmTypeReference_0 = null; + + EObject this_JvmWildcardTypeReference_1 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:779:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ) + // InternalTqcl.g:780:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + { + // InternalTqcl.g:780:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==RULE_ID||LA16_0==18||LA16_0==21) ) { + alt16=1; + } + else if ( (LA16_0==25) ) { + alt16=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + switch (alt16) { + case 1 : + // InternalTqcl.g:781:3: this_JvmTypeReference_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_JvmTypeReference_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmTypeReference_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalTqcl.g:790:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmWildcardTypeReference_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmArgumentTypeReference" + + + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalTqcl.g:802:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ; + public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmWildcardTypeReference = null; + + + try { + // InternalTqcl.g:802:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ) + // InternalTqcl.g:803:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmWildcardTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmWildcardTypeReference" + + + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalTqcl.g:809:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ; + public final EObject ruleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_constraints_2_0 = null; + + EObject lv_constraints_3_0 = null; + + EObject lv_constraints_4_0 = null; + + EObject lv_constraints_5_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:815:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ) + // InternalTqcl.g:816:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + { + // InternalTqcl.g:816:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + // InternalTqcl.g:817:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + { + // InternalTqcl.g:817:3: () + // InternalTqcl.g:818:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,25,FOLLOW_22); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + + } + // InternalTqcl.g:828:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + int alt19=3; + int LA19_0 = input.LA(1); + + if ( (LA19_0==26) ) { + alt19=1; + } + else if ( (LA19_0==28) ) { + alt19=2; + } + switch (alt19) { + case 1 : + // InternalTqcl.g:829:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + { + // InternalTqcl.g:829:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + // InternalTqcl.g:830:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + { + // InternalTqcl.g:830:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) + // InternalTqcl.g:831:6: (lv_constraints_2_0= ruleJvmUpperBound ) + { + // InternalTqcl.g:831:6: (lv_constraints_2_0= ruleJvmUpperBound ) + // InternalTqcl.g:832:7: lv_constraints_2_0= ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + + } + pushFollow(FOLLOW_23); + lv_constraints_2_0=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:849:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==27) ) { + alt17=1; + } + + + switch (alt17) { + case 1 : + // InternalTqcl.g:850:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + { + // InternalTqcl.g:850:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + // InternalTqcl.g:851:7: lv_constraints_3_0= ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_23); + lv_constraints_3_0=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop17; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalTqcl.g:870:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + { + // InternalTqcl.g:870:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + // InternalTqcl.g:871:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + { + // InternalTqcl.g:871:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) + // InternalTqcl.g:872:6: (lv_constraints_4_0= ruleJvmLowerBound ) + { + // InternalTqcl.g:872:6: (lv_constraints_4_0= ruleJvmLowerBound ) + // InternalTqcl.g:873:7: lv_constraints_4_0= ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + + } + pushFollow(FOLLOW_23); + lv_constraints_4_0=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:890:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + loop18: + do { + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==27) ) { + alt18=1; + } + + + switch (alt18) { + case 1 : + // InternalTqcl.g:891:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + { + // InternalTqcl.g:891:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + // InternalTqcl.g:892:7: lv_constraints_5_0= ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_23); + lv_constraints_5_0=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop18; + } + } while (true); + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmWildcardTypeReference" + + + // $ANTLR start "entryRuleJvmUpperBound" + // InternalTqcl.g:915:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ; + public final EObject entryRuleJvmUpperBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBound = null; + + + try { + // InternalTqcl.g:915:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ) + // InternalTqcl.g:916:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBound=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBound" + + + // $ANTLR start "ruleJvmUpperBound" + // InternalTqcl.g:922:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:928:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalTqcl.g:929:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalTqcl.g:929:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalTqcl.g:930:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,26,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + + } + // InternalTqcl.g:934:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:935:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:935:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalTqcl.g:936:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBound" + + + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalTqcl.g:957:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ; + public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBoundAnded = null; + + + try { + // InternalTqcl.g:957:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ) + // InternalTqcl.g:958:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBoundAnded" + + + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalTqcl.g:964:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:970:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalTqcl.g:971:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalTqcl.g:971:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalTqcl.g:972:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,27,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalTqcl.g:976:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:977:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:977:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalTqcl.g:978:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBoundAnded" + + + // $ANTLR start "entryRuleJvmLowerBound" + // InternalTqcl.g:999:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ; + public final EObject entryRuleJvmLowerBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBound = null; + + + try { + // InternalTqcl.g:999:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ) + // InternalTqcl.g:1000:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBound=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBound" + + + // $ANTLR start "ruleJvmLowerBound" + // InternalTqcl.g:1006:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1012:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalTqcl.g:1013:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalTqcl.g:1013:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalTqcl.g:1014:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,28,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + + } + // InternalTqcl.g:1018:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:1019:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:1019:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalTqcl.g:1020:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBound" + + + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalTqcl.g:1041:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ; + public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBoundAnded = null; + + + try { + // InternalTqcl.g:1041:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ) + // InternalTqcl.g:1042:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBoundAnded" + + + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalTqcl.g:1048:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1054:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalTqcl.g:1055:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalTqcl.g:1055:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalTqcl.g:1056:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,27,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalTqcl.g:1060:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalTqcl.g:1061:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalTqcl.g:1061:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalTqcl.g:1062:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBoundAnded" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalTqcl.g:1083:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + public final String entryRuleQualifiedName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedName = null; + + + try { + // InternalTqcl.g:1083:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalTqcl.g:1084:2: iv_ruleQualifiedName= ruleQualifiedName EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedName=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedName.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalTqcl.g:1090:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID (kw= '.' this_ValidID_2= ruleValidID )* ) ; + public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + AntlrDatatypeRuleToken this_ValidID_2 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1096:2: ( (this_ValidID_0= ruleValidID (kw= '.' this_ValidID_2= ruleValidID )* ) ) + // InternalTqcl.g:1097:2: (this_ValidID_0= ruleValidID (kw= '.' this_ValidID_2= ruleValidID )* ) + { + // InternalTqcl.g:1097:2: (this_ValidID_0= ruleValidID (kw= '.' this_ValidID_2= ruleValidID )* ) + // InternalTqcl.g:1098:3: this_ValidID_0= ruleValidID (kw= '.' this_ValidID_2= ruleValidID )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_20); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalTqcl.g:1108:3: (kw= '.' this_ValidID_2= ruleValidID )* + loop20: + do { + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==24) ) { + int LA20_2 = input.LA(2); + + if ( (LA20_2==RULE_ID) ) { + alt20=1; + } + + + } + + + switch (alt20) { + case 1 : + // InternalTqcl.g:1109:4: kw= '.' this_ValidID_2= ruleValidID + { + kw=(Token)match(input,24,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + + } + pushFollow(FOLLOW_20); + this_ValidID_2=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_2); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + + default : + break loop20; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalTqcl.g:1129:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ; + public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null; + + + try { + // InternalTqcl.g:1129:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ) + // InternalTqcl.g:1130:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameWithWildcard.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameWithWildcard" + + + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalTqcl.g:1136:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ; + public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_QualifiedName_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1142:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ) + // InternalTqcl.g:1143:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + { + // InternalTqcl.g:1143:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + // InternalTqcl.g:1144:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + + } + pushFollow(FOLLOW_24); + this_QualifiedName_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_QualifiedName_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,24,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + + } + kw=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameWithWildcard" + + + // $ANTLR start "entryRuleValidID" + // InternalTqcl.g:1168:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ; + public final String entryRuleValidID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleValidID = null; + + + try { + // InternalTqcl.g:1168:47: (iv_ruleValidID= ruleValidID EOF ) + // InternalTqcl.g:1169:2: iv_ruleValidID= ruleValidID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleValidID=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleValidID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleValidID" + + + // $ANTLR start "ruleValidID" + // InternalTqcl.g:1175:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ; + public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ID_0=null; + + + enterRule(); + + try { + // InternalTqcl.g:1181:2: (this_ID_0= RULE_ID ) + // InternalTqcl.g:1182:2: this_ID_0= RULE_ID + { + this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ID_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleValidID" + + + // $ANTLR start "entryRuleXImportDeclaration" + // InternalTqcl.g:1192:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ; + public final EObject entryRuleXImportDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXImportDeclaration = null; + + + try { + // InternalTqcl.g:1192:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ) + // InternalTqcl.g:1193:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXImportDeclaration=ruleXImportDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXImportDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXImportDeclaration" + + + // $ANTLR start "ruleXImportDeclaration" + // InternalTqcl.g:1199:1: ruleXImportDeclaration returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ; + public final EObject ruleXImportDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_static_1_0=null; + Token lv_extension_2_0=null; + Token lv_wildcard_4_0=null; + Token otherlv_8=null; + AntlrDatatypeRuleToken lv_memberName_5_0 = null; + + AntlrDatatypeRuleToken lv_importedNamespace_7_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1205:2: ( (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ) + // InternalTqcl.g:1206:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + { + // InternalTqcl.g:1206:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + // InternalTqcl.g:1207:3: otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? + { + otherlv_0=(Token)match(input,30,FOLLOW_26); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + + } + // InternalTqcl.g:1211:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) + int alt23=3; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalTqcl.g:1212:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + { + // InternalTqcl.g:1212:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + // InternalTqcl.g:1213:5: ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + { + // InternalTqcl.g:1213:5: ( (lv_static_1_0= 'static' ) ) + // InternalTqcl.g:1214:6: (lv_static_1_0= 'static' ) + { + // InternalTqcl.g:1214:6: (lv_static_1_0= 'static' ) + // InternalTqcl.g:1215:7: lv_static_1_0= 'static' + { + lv_static_1_0=(Token)match(input,31,FOLLOW_27); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "static", true, "static"); + + } + + } + + + } + + // InternalTqcl.g:1227:5: ( (lv_extension_2_0= 'extension' ) )? + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==32) ) { + alt21=1; + } + switch (alt21) { + case 1 : + // InternalTqcl.g:1228:6: (lv_extension_2_0= 'extension' ) + { + // InternalTqcl.g:1228:6: (lv_extension_2_0= 'extension' ) + // InternalTqcl.g:1229:7: lv_extension_2_0= 'extension' + { + lv_extension_2_0=(Token)match(input,32,FOLLOW_27); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "extension", true, "extension"); + + } + + } + + + } + break; + + } + + // InternalTqcl.g:1241:5: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalTqcl.g:1242:6: ( ruleQualifiedNameInStaticImport ) + { + // InternalTqcl.g:1242:6: ( ruleQualifiedNameInStaticImport ) + // InternalTqcl.g:1243:7: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + + } + pushFollow(FOLLOW_28); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalTqcl.g:1257:5: ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==29) ) { + alt22=1; + } + else if ( (LA22_0==RULE_ID) ) { + alt22=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + + throw nvae; + } + switch (alt22) { + case 1 : + // InternalTqcl.g:1258:6: ( (lv_wildcard_4_0= '*' ) ) + { + // InternalTqcl.g:1258:6: ( (lv_wildcard_4_0= '*' ) ) + // InternalTqcl.g:1259:7: (lv_wildcard_4_0= '*' ) + { + // InternalTqcl.g:1259:7: (lv_wildcard_4_0= '*' ) + // InternalTqcl.g:1260:8: lv_wildcard_4_0= '*' + { + lv_wildcard_4_0=(Token)match(input,29,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "wildcard", true, "*"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalTqcl.g:1273:6: ( (lv_memberName_5_0= ruleValidID ) ) + { + // InternalTqcl.g:1273:6: ( (lv_memberName_5_0= ruleValidID ) ) + // InternalTqcl.g:1274:7: (lv_memberName_5_0= ruleValidID ) + { + // InternalTqcl.g:1274:7: (lv_memberName_5_0= ruleValidID ) + // InternalTqcl.g:1275:8: lv_memberName_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + + } + pushFollow(FOLLOW_29); + lv_memberName_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalTqcl.g:1295:4: ( ( ruleQualifiedName ) ) + { + // InternalTqcl.g:1295:4: ( ( ruleQualifiedName ) ) + // InternalTqcl.g:1296:5: ( ruleQualifiedName ) + { + // InternalTqcl.g:1296:5: ( ruleQualifiedName ) + // InternalTqcl.g:1297:6: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + + } + pushFollow(FOLLOW_29); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 3 : + // InternalTqcl.g:1312:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + { + // InternalTqcl.g:1312:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + // InternalTqcl.g:1313:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + { + // InternalTqcl.g:1313:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + // InternalTqcl.g:1314:6: lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + + } + pushFollow(FOLLOW_29); + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalTqcl.g:1332:3: (otherlv_8= ';' )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==33) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalTqcl.g:1333:4: otherlv_8= ';' + { + otherlv_8=(Token)match(input,33,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + + } + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXImportDeclaration" + + + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalTqcl.g:1342:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ; + public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null; + + + try { + // InternalTqcl.g:1342:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ) + // InternalTqcl.g:1343:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameInStaticImport.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalTqcl.g:1349:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ; + public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalTqcl.g:1355:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ ) + // InternalTqcl.g:1356:2: (this_ValidID_0= ruleValidID kw= '.' )+ + { + // InternalTqcl.g:1356:2: (this_ValidID_0= ruleValidID kw= '.' )+ + int cnt25=0; + loop25: + do { + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_ID) ) { + int LA25_2 = input.LA(2); + + if ( (LA25_2==24) ) { + alt25=1; + } + + + } + + + switch (alt25) { + case 1 : + // InternalTqcl.g:1357:3: this_ValidID_0= ruleValidID kw= '.' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_24); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,24,FOLLOW_7); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + + } + + } + break; + + default : + if ( cnt25 >= 1 ) break loop25; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(25, input); + throw eee; + } + cnt25++; + } while (true); + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameInStaticImport" + + // $ANTLR start synpred1_InternalTqcl + public final void synpred1_InternalTqcl_fragment() throws RecognitionException { + // InternalTqcl.g:414:5: ( ( () ruleArrayBrackets ) ) + // InternalTqcl.g:414:6: ( () ruleArrayBrackets ) + { + // InternalTqcl.g:414:6: ( () ruleArrayBrackets ) + // InternalTqcl.g:415:6: () ruleArrayBrackets + { + // InternalTqcl.g:415:6: () + // InternalTqcl.g:416:6: + { + } + + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred1_InternalTqcl + + // $ANTLR start synpred2_InternalTqcl + public final void synpred2_InternalTqcl_fragment() throws RecognitionException { + // InternalTqcl.g:611:5: ( '<' ) + // InternalTqcl.g:611:6: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred2_InternalTqcl + + // $ANTLR start synpred3_InternalTqcl + public final void synpred3_InternalTqcl_fragment() throws RecognitionException { + // InternalTqcl.g:667:6: ( ( () '.' ) ) + // InternalTqcl.g:667:7: ( () '.' ) + { + // InternalTqcl.g:667:7: ( () '.' ) + // InternalTqcl.g:668:7: () '.' + { + // InternalTqcl.g:668:7: () + // InternalTqcl.g:669:7: + { + } + + match(input,24,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred3_InternalTqcl + + // $ANTLR start synpred4_InternalTqcl + public final void synpred4_InternalTqcl_fragment() throws RecognitionException { + // InternalTqcl.g:705:7: ( '<' ) + // InternalTqcl.g:705:8: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred4_InternalTqcl + + // Delegated rules + + public final boolean synpred3_InternalTqcl() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_InternalTqcl_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred1_InternalTqcl() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_InternalTqcl_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred2_InternalTqcl() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_InternalTqcl_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_InternalTqcl() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_InternalTqcl_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA23 dfa23 = new DFA23(this); + static final String dfa_1s = "\7\uffff"; + static final String dfa_2s = "\2\uffff\1\4\3\uffff\1\4"; + static final String dfa_3s = "\1\5\1\uffff\1\30\1\5\2\uffff\1\30"; + static final String dfa_4s = "\1\37\1\uffff\1\41\1\35\2\uffff\1\41"; + static final String dfa_5s = "\1\uffff\1\1\2\uffff\1\2\1\3\1\uffff"; + static final String dfa_6s = "\7\uffff}>"; + static final String[] dfa_7s = { + "\1\2\31\uffff\1\1", + "", + "\1\3\10\uffff\1\4", + "\1\6\27\uffff\1\5", + "", + "", + "\1\3\10\uffff\1\4" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); + static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); + + class DFA23 extends DFA { + + public DFA23(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 23; + this.eot = dfa_1; + this.eof = dfa_2; + this.min = dfa_3; + this.max = dfa_4; + this.accept = dfa_5; + this.special = dfa_6; + this.transition = dfa_7; + } + public String getDescription() { + return "1211:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) )"; + } + } + + + public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); + public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000004402L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000020L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001802L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000001002L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000022L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000002000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000010002L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000020000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000340020L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000180000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000240020L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000400002L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002240020L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000880000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000001000002L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000001400002L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000014000002L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000008000002L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000080000020L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000100000020L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000020000020L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000002L}); + +} \ No newline at end of file diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/scoping/AbstractTqclScopeProvider.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/scoping/AbstractTqclScopeProvider.java new file mode 100644 index 00000000..d1cc3754 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/scoping/AbstractTqclScopeProvider.java @@ -0,0 +1,9 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.scoping; + +import org.eclipse.xtext.xbase.scoping.XtypeScopeProvider; + +public abstract class AbstractTqclScopeProvider extends XtypeScopeProvider { +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSemanticSequencer.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSemanticSequencer.java new file mode 100644 index 00000000..b5dbff77 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSemanticSequencer.java @@ -0,0 +1,216 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.serializer; + +import com.google.inject.Inject; +import java.util.Set; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.triquetrum.commands.services.TqclGrammarAccess; +import org.eclipse.triquetrum.commands.tqcl.Connect; +import org.eclipse.triquetrum.commands.tqcl.Insert; +import org.eclipse.triquetrum.commands.tqcl.NamedObj; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; +import org.eclipse.triquetrum.commands.tqcl.TriquetrumScript; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Parameter; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference; +import org.eclipse.xtext.common.types.JvmInnerTypeReference; +import org.eclipse.xtext.common.types.JvmLowerBound; +import org.eclipse.xtext.common.types.JvmParameterizedTypeReference; +import org.eclipse.xtext.common.types.JvmTypeParameter; +import org.eclipse.xtext.common.types.JvmUpperBound; +import org.eclipse.xtext.common.types.JvmWildcardTypeReference; +import org.eclipse.xtext.common.types.TypesPackage; +import org.eclipse.xtext.serializer.ISerializationContext; +import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; +import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; +import org.eclipse.xtext.xbase.serializer.XtypeSemanticSequencer; +import org.eclipse.xtext.xtype.XFunctionTypeRef; +import org.eclipse.xtext.xtype.XImportDeclaration; +import org.eclipse.xtext.xtype.XImportSection; +import org.eclipse.xtext.xtype.XtypePackage; + +@SuppressWarnings("all") +public abstract class AbstractTqclSemanticSequencer extends XtypeSemanticSequencer { + + @Inject + private TqclGrammarAccess grammarAccess; + + @Override + public void sequence(ISerializationContext context, EObject semanticObject) { + EPackage epackage = semanticObject.eClass().getEPackage(); + ParserRule rule = context.getParserRule(); + Action action = context.getAssignedAction(); + Set parameters = context.getEnabledBooleanParameters(); + if (epackage == TqclPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case TqclPackage.CONNECT: + sequence_Connect(context, (Connect) semanticObject); + return; + case TqclPackage.INSERT: + sequence_Insert(context, (Insert) semanticObject); + return; + case TqclPackage.NAMED_OBJ: + sequence_NamedObj(context, (NamedObj) semanticObject); + return; + case TqclPackage.PARAMETER: + sequence_Parameter(context, (org.eclipse.triquetrum.commands.tqcl.Parameter) semanticObject); + return; + case TqclPackage.TRIQUETRUM_SCRIPT: + sequence_TriquetrumScript(context, (TriquetrumScript) semanticObject); + return; + } + else if (epackage == TypesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE: + sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); + return; + case TypesPackage.JVM_INNER_TYPE_REFERENCE: + sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); + return; + case TypesPackage.JVM_LOWER_BOUND: + if (rule == grammarAccess.getJvmLowerBoundAndedRule()) { + sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmLowerBoundRule()) { + sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE: + if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) { + sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmTypeReferenceRule() + || action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0() + || rule == grammarAccess.getJvmParameterizedTypeReferenceRule() + || rule == grammarAccess.getJvmArgumentTypeReferenceRule()) { + sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else break; + case TypesPackage.JVM_TYPE_PARAMETER: + sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); + return; + case TypesPackage.JVM_UPPER_BOUND: + if (rule == grammarAccess.getJvmUpperBoundAndedRule()) { + sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmUpperBoundRule()) { + sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE: + sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); + return; + } + else if (epackage == XtypePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XtypePackage.XFUNCTION_TYPE_REF: + sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); + return; + case XtypePackage.XIMPORT_DECLARATION: + sequence_XImportDeclaration(context, (XImportDeclaration) semanticObject); + return; + case XtypePackage.XIMPORT_SECTION: + sequence_XImportSection(context, (XImportSection) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * Command returns Connect + * Connect returns Connect + * + * Constraint: + * (from=NamedObj to=NamedObj) + */ + protected void sequence_Connect(ISerializationContext context, Connect semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, TqclPackage.Literals.CONNECT__FROM) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TqclPackage.Literals.CONNECT__FROM)); + if (transientValues.isValueTransient(semanticObject, TqclPackage.Literals.CONNECT__TO) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TqclPackage.Literals.CONNECT__TO)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getConnectAccess().getFromNamedObjParserRuleCall_1_0(), semanticObject.getFrom()); + feeder.accept(grammarAccess.getConnectAccess().getToNamedObjParserRuleCall_3_0(), semanticObject.getTo()); + feeder.finish(); + } + + + /** + * Contexts: + * Command returns Insert + * Insert returns Insert + * + * Constraint: + * (obj=QualifiedName alias=NamedObj? parameters+=Parameter*) + */ + protected void sequence_Insert(ISerializationContext context, Insert semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * NamedObj returns NamedObj + * + * Constraint: + * name=QualifiedName + */ + protected void sequence_NamedObj(ISerializationContext context, NamedObj semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, TqclPackage.Literals.NAMED_OBJ__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TqclPackage.Literals.NAMED_OBJ__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getNamedObjAccess().getNameQualifiedNameParserRuleCall_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Parameter returns Parameter + * + * Constraint: + * (name=QualifiedName value=STRING) + */ + protected void sequence_Parameter(ISerializationContext context, org.eclipse.triquetrum.commands.tqcl.Parameter semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, TqclPackage.Literals.PARAMETER__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TqclPackage.Literals.PARAMETER__NAME)); + if (transientValues.isValueTransient(semanticObject, TqclPackage.Literals.PARAMETER__VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TqclPackage.Literals.PARAMETER__VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getParameterAccess().getNameQualifiedNameParserRuleCall_0_0(), semanticObject.getName()); + feeder.accept(grammarAccess.getParameterAccess().getValueSTRINGTerminalRuleCall_2_0(), semanticObject.getValue()); + feeder.finish(); + } + + + /** + * Contexts: + * TriquetrumScript returns TriquetrumScript + * + * Constraint: + * commands+=Command+ + */ + protected void sequence_TriquetrumScript(ISerializationContext context, TriquetrumScript semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSyntacticSequencer.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSyntacticSequencer.java new file mode 100644 index 00000000..65fe1bf7 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/serializer/AbstractTqclSyntacticSequencer.java @@ -0,0 +1,107 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.serializer; + +import com.google.inject.Inject; +import java.util.List; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.triquetrum.commands.services.TqclGrammarAccess; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.nodemodel.INode; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; +import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer; + +@SuppressWarnings("all") +public abstract class AbstractTqclSyntacticSequencer extends AbstractSyntacticSequencer { + + protected TqclGrammarAccess grammarAccess; + protected AbstractElementAlias match_Insert_WithKeyword_3_0_q; + protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q; + protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_2_q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (TqclGrammarAccess) access; + match_Insert_WithKeyword_3_0_q = new TokenAlias(false, true, grammarAccess.getInsertAccess().getWithKeyword_3_0()); + match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2())); + match_XImportDeclaration_SemicolonKeyword_2_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + + @Override + protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule()) + return getArrayBracketsToken(semanticObject, ruleCall, node); + return ""; + } + + /** + * ArrayBrackets : + * '[' ']' + * ; + */ + protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "[]"; + } + + @Override + protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { + if (transition.getAmbiguousSyntaxes().isEmpty()) return; + List transitionNodes = collectNodes(fromNode, toNode); + for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { + List syntaxNodes = getNodesFor(transitionNodes, syntax); + if (match_Insert_WithKeyword_3_0_q.equals(syntax)) + emit_Insert_WithKeyword_3_0_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax)) + emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XImportDeclaration_SemicolonKeyword_2_q.equals(syntax)) + emit_XImportDeclaration_SemicolonKeyword_2_q(semanticObject, getLastNavigableState(), syntaxNodes); + else acceptNodes(getLastNavigableState(), syntaxNodes); + } + } + + /** + * Ambiguous syntax: + * 'with'? + * + * This ambiguous syntax occurs at: + * alias=NamedObj (ambiguity) (rule end) + * obj=QualifiedName (ambiguity) (rule end) + */ + protected void emit_Insert_WithKeyword_3_0_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('(' ')')? + * + * This ambiguous syntax occurs at: + * (rule start) (ambiguity) '=>' returnType=JvmTypeReference + */ + protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ';'? + * + * This ambiguous syntax occurs at: + * importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end) + * importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end) + * memberName=ValidID (ambiguity) (rule end) + * wildcard?='*' (ambiguity) (rule end) + */ + protected void emit_XImportDeclaration_SemicolonKeyword_2_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/services/TqclGrammarAccess.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/services/TqclGrammarAccess.java new file mode 100644 index 00000000..3df26b46 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/services/TqclGrammarAccess.java @@ -0,0 +1,520 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import java.util.List; +import org.eclipse.xtext.Alternatives; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.Grammar; +import org.eclipse.xtext.GrammarUtil; +import org.eclipse.xtext.Group; +import org.eclipse.xtext.Keyword; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.TerminalRule; +import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; +import org.eclipse.xtext.service.GrammarProvider; +import org.eclipse.xtext.xbase.services.XtypeGrammarAccess; + +@Singleton +public class TqclGrammarAccess extends AbstractGrammarElementFinder { + + public class TriquetrumScriptElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.TriquetrumScript"); + private final Assignment cCommandsAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cCommandsCommandParserRuleCall_0 = (RuleCall)cCommandsAssignment.eContents().get(0); + + //TriquetrumScript: + // commands+=Command*; + @Override public ParserRule getRule() { return rule; } + + //commands+=Command* + public Assignment getCommandsAssignment() { return cCommandsAssignment; } + + //Command + public RuleCall getCommandsCommandParserRuleCall_0() { return cCommandsCommandParserRuleCall_0; } + } + public class CommandElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.Command"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cInsertParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cConnectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //Command: + // Insert | Connect; + @Override public ParserRule getRule() { return rule; } + + //Insert | Connect + public Alternatives getAlternatives() { return cAlternatives; } + + //Insert + public RuleCall getInsertParserRuleCall_0() { return cInsertParserRuleCall_0; } + + //Connect + public RuleCall getConnectParserRuleCall_1() { return cConnectParserRuleCall_1; } + } + public class InsertElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.Insert"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cInsertKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cObjAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cObjQualifiedNameParserRuleCall_1_0 = (RuleCall)cObjAssignment_1.eContents().get(0); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cAsKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cAliasAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cAliasNamedObjParserRuleCall_2_1_0 = (RuleCall)cAliasAssignment_2_1.eContents().get(0); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cWithKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final Assignment cParametersAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); + private final RuleCall cParametersParameterParserRuleCall_3_1_0 = (RuleCall)cParametersAssignment_3_1.eContents().get(0); + + //Insert: + // "insert" obj=QualifiedName ("as" alias=NamedObj)? ("with" parameters+=Parameter*)?; + @Override public ParserRule getRule() { return rule; } + + //"insert" obj=QualifiedName ("as" alias=NamedObj)? ("with" parameters+=Parameter*)? + public Group getGroup() { return cGroup; } + + //"insert" + public Keyword getInsertKeyword_0() { return cInsertKeyword_0; } + + //obj=QualifiedName + public Assignment getObjAssignment_1() { return cObjAssignment_1; } + + //QualifiedName + public RuleCall getObjQualifiedNameParserRuleCall_1_0() { return cObjQualifiedNameParserRuleCall_1_0; } + + //("as" alias=NamedObj)? + public Group getGroup_2() { return cGroup_2; } + + //"as" + public Keyword getAsKeyword_2_0() { return cAsKeyword_2_0; } + + //alias=NamedObj + public Assignment getAliasAssignment_2_1() { return cAliasAssignment_2_1; } + + //NamedObj + public RuleCall getAliasNamedObjParserRuleCall_2_1_0() { return cAliasNamedObjParserRuleCall_2_1_0; } + + //("with" parameters+=Parameter*)? + public Group getGroup_3() { return cGroup_3; } + + //"with" + public Keyword getWithKeyword_3_0() { return cWithKeyword_3_0; } + + //parameters+=Parameter* + public Assignment getParametersAssignment_3_1() { return cParametersAssignment_3_1; } + + //Parameter + public RuleCall getParametersParameterParserRuleCall_3_1_0() { return cParametersParameterParserRuleCall_3_1_0; } + } + public class ParameterElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.Parameter"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cNameQualifiedNameParserRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0); + private final Keyword cEqualsSignKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cValueAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cValueSTRINGTerminalRuleCall_2_0 = (RuleCall)cValueAssignment_2.eContents().get(0); + + //Parameter: + // name=QualifiedName "=" value=STRING; + @Override public ParserRule getRule() { return rule; } + + //name=QualifiedName "=" value=STRING + public Group getGroup() { return cGroup; } + + //name=QualifiedName + public Assignment getNameAssignment_0() { return cNameAssignment_0; } + + //QualifiedName + public RuleCall getNameQualifiedNameParserRuleCall_0_0() { return cNameQualifiedNameParserRuleCall_0_0; } + + //"=" + public Keyword getEqualsSignKeyword_1() { return cEqualsSignKeyword_1; } + + //value=STRING + public Assignment getValueAssignment_2() { return cValueAssignment_2; } + + //STRING + public RuleCall getValueSTRINGTerminalRuleCall_2_0() { return cValueSTRINGTerminalRuleCall_2_0; } + } + public class NamedObjElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.NamedObj"); + private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cNameQualifiedNameParserRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); + + //NamedObj: + // name=QualifiedName; + @Override public ParserRule getRule() { return rule; } + + //name=QualifiedName + public Assignment getNameAssignment() { return cNameAssignment; } + + //QualifiedName + public RuleCall getNameQualifiedNameParserRuleCall_0() { return cNameQualifiedNameParserRuleCall_0; } + } + public class ConnectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.triquetrum.commands.Tqcl.Connect"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cConnectKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cFromAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cFromNamedObjParserRuleCall_1_0 = (RuleCall)cFromAssignment_1.eContents().get(0); + private final Keyword cToKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Assignment cToAssignment_3 = (Assignment)cGroup.eContents().get(3); + private final RuleCall cToNamedObjParserRuleCall_3_0 = (RuleCall)cToAssignment_3.eContents().get(0); + + //Connect: + // "connect" from=NamedObj "to" to=NamedObj; + @Override public ParserRule getRule() { return rule; } + + //"connect" from=NamedObj "to" to=NamedObj + public Group getGroup() { return cGroup; } + + //"connect" + public Keyword getConnectKeyword_0() { return cConnectKeyword_0; } + + //from=NamedObj + public Assignment getFromAssignment_1() { return cFromAssignment_1; } + + //NamedObj + public RuleCall getFromNamedObjParserRuleCall_1_0() { return cFromNamedObjParserRuleCall_1_0; } + + //"to" + public Keyword getToKeyword_2() { return cToKeyword_2; } + + //to=NamedObj + public Assignment getToAssignment_3() { return cToAssignment_3; } + + //NamedObj + public RuleCall getToNamedObjParserRuleCall_3_0() { return cToNamedObjParserRuleCall_3_0; } + } + + + private final TriquetrumScriptElements pTriquetrumScript; + private final CommandElements pCommand; + private final InsertElements pInsert; + private final ParameterElements pParameter; + private final NamedObjElements pNamedObj; + private final ConnectElements pConnect; + + private final Grammar grammar; + + private final XtypeGrammarAccess gaXtype; + + @Inject + public TqclGrammarAccess(GrammarProvider grammarProvider, + XtypeGrammarAccess gaXtype) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaXtype = gaXtype; + this.pTriquetrumScript = new TriquetrumScriptElements(); + this.pCommand = new CommandElements(); + this.pInsert = new InsertElements(); + this.pParameter = new ParameterElements(); + this.pNamedObj = new NamedObjElements(); + this.pConnect = new ConnectElements(); + } + + protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { + Grammar grammar = grammarProvider.getGrammar(this); + while (grammar != null) { + if ("org.eclipse.triquetrum.commands.Tqcl".equals(grammar.getName())) { + return grammar; + } + List grammars = grammar.getUsedGrammars(); + if (!grammars.isEmpty()) { + grammar = grammars.iterator().next(); + } else { + return null; + } + } + return grammar; + } + + @Override + public Grammar getGrammar() { + return grammar; + } + + + public XtypeGrammarAccess getXtypeGrammarAccess() { + return gaXtype; + } + + + //TriquetrumScript: + // commands+=Command*; + public TriquetrumScriptElements getTriquetrumScriptAccess() { + return pTriquetrumScript; + } + + public ParserRule getTriquetrumScriptRule() { + return getTriquetrumScriptAccess().getRule(); + } + + //Command: + // Insert | Connect; + public CommandElements getCommandAccess() { + return pCommand; + } + + public ParserRule getCommandRule() { + return getCommandAccess().getRule(); + } + + //Insert: + // "insert" obj=QualifiedName ("as" alias=NamedObj)? ("with" parameters+=Parameter*)?; + public InsertElements getInsertAccess() { + return pInsert; + } + + public ParserRule getInsertRule() { + return getInsertAccess().getRule(); + } + + //Parameter: + // name=QualifiedName "=" value=STRING; + public ParameterElements getParameterAccess() { + return pParameter; + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //NamedObj: + // name=QualifiedName; + public NamedObjElements getNamedObjAccess() { + return pNamedObj; + } + + public ParserRule getNamedObjRule() { + return getNamedObjAccess().getRule(); + } + + //Connect: + // "connect" from=NamedObj "to" to=NamedObj; + public ConnectElements getConnectAccess() { + return pConnect; + } + + public ParserRule getConnectRule() { + return getConnectAccess().getRule(); + } + + //JvmTypeReference: + // JvmParameterizedTypeReference => ({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* + // | XFunctionTypeRef; + public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() { + return gaXtype.getJvmTypeReferenceAccess(); + } + + public ParserRule getJvmTypeReferenceRule() { + return getJvmTypeReferenceAccess().getRule(); + } + + //ArrayBrackets: + // '[' ']'; + public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() { + return gaXtype.getArrayBracketsAccess(); + } + + public ParserRule getArrayBracketsRule() { + return getArrayBracketsAccess().getRule(); + } + + //XFunctionTypeRef: + // ('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference; + public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() { + return gaXtype.getXFunctionTypeRefAccess(); + } + + public ParserRule getXFunctionTypeRefRule() { + return getXFunctionTypeRefAccess().getRule(); + } + + //JvmParameterizedTypeReference: + // type=[JvmType|QualifiedName] (=> '<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* + // '>' (=> ({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=> '<' arguments+=JvmArgumentTypeReference + // (',' arguments+=JvmArgumentTypeReference)* '>')?)*)?; + public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() { + return gaXtype.getJvmParameterizedTypeReferenceAccess(); + } + + public ParserRule getJvmParameterizedTypeReferenceRule() { + return getJvmParameterizedTypeReferenceAccess().getRule(); + } + + //JvmArgumentTypeReference JvmTypeReference: + // JvmTypeReference | JvmWildcardTypeReference + public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() { + return gaXtype.getJvmArgumentTypeReferenceAccess(); + } + + public ParserRule getJvmArgumentTypeReferenceRule() { + return getJvmArgumentTypeReferenceAccess().getRule(); + } + + //JvmWildcardTypeReference: + // {JvmWildcardTypeReference} '?' (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded* + // | constraints+=JvmLowerBound constraints+=JvmLowerBoundAnded*)?; + public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() { + return gaXtype.getJvmWildcardTypeReferenceAccess(); + } + + public ParserRule getJvmWildcardTypeReferenceRule() { + return getJvmWildcardTypeReferenceAccess().getRule(); + } + + //JvmUpperBound: + // 'extends' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() { + return gaXtype.getJvmUpperBoundAccess(); + } + + public ParserRule getJvmUpperBoundRule() { + return getJvmUpperBoundAccess().getRule(); + } + + //JvmUpperBoundAnded JvmUpperBound: + // '&' typeReference=JvmTypeReference + public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() { + return gaXtype.getJvmUpperBoundAndedAccess(); + } + + public ParserRule getJvmUpperBoundAndedRule() { + return getJvmUpperBoundAndedAccess().getRule(); + } + + //JvmLowerBound: + // 'super' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() { + return gaXtype.getJvmLowerBoundAccess(); + } + + public ParserRule getJvmLowerBoundRule() { + return getJvmLowerBoundAccess().getRule(); + } + + //JvmLowerBoundAnded JvmLowerBound: + // '&' typeReference=JvmTypeReference + public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() { + return gaXtype.getJvmLowerBoundAndedAccess(); + } + + public ParserRule getJvmLowerBoundAndedRule() { + return getJvmLowerBoundAndedAccess().getRule(); + } + + //JvmTypeParameter: + // name=ValidID (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*)?; + public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() { + return gaXtype.getJvmTypeParameterAccess(); + } + + public ParserRule getJvmTypeParameterRule() { + return getJvmTypeParameterAccess().getRule(); + } + + //QualifiedName: + // ValidID ('.' ValidID)*; + public XtypeGrammarAccess.QualifiedNameElements getQualifiedNameAccess() { + return gaXtype.getQualifiedNameAccess(); + } + + public ParserRule getQualifiedNameRule() { + return getQualifiedNameAccess().getRule(); + } + + //QualifiedNameWithWildcard: + // QualifiedName '.' '*'; + public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() { + return gaXtype.getQualifiedNameWithWildcardAccess(); + } + + public ParserRule getQualifiedNameWithWildcardRule() { + return getQualifiedNameWithWildcardAccess().getRule(); + } + + //ValidID: + // ID; + public XtypeGrammarAccess.ValidIDElements getValidIDAccess() { + return gaXtype.getValidIDAccess(); + } + + public ParserRule getValidIDRule() { + return getValidIDAccess().getRule(); + } + + //XImportSection: + // importDeclarations+=XImportDeclaration+; + public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() { + return gaXtype.getXImportSectionAccess(); + } + + public ParserRule getXImportSectionRule() { + return getXImportSectionAccess().getRule(); + } + + //XImportDeclaration: + // 'import' (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] + // (wildcard?='*' | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] | + // importedNamespace=QualifiedNameWithWildcard) ';'?; + public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() { + return gaXtype.getXImportDeclarationAccess(); + } + + public ParserRule getXImportDeclarationRule() { + return getXImportDeclarationAccess().getRule(); + } + + //QualifiedNameInStaticImport: + // (ValidID '.')+; + public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() { + return gaXtype.getQualifiedNameInStaticImportAccess(); + } + + public ParserRule getQualifiedNameInStaticImportRule() { + return getQualifiedNameInStaticImportAccess().getRule(); + } + + //terminal ID: + // '^'? ('a'..'z' | 'A'..'Z' | '$' | '_') ('a'..'z' | 'A'..'Z' | '$' | '_' | '0'..'9')*; + public TerminalRule getIDRule() { + return gaXtype.getIDRule(); + } + + //terminal STRING: + // '"' ('\\' . | !('\\' | '"'))* '"'? | + // "'" ('\\' . | !('\\' | "'"))* "'"?; + public TerminalRule getSTRINGRule() { + return gaXtype.getSTRINGRule(); + } + + //terminal ML_COMMENT: + // '/ *'->'* /'; + public TerminalRule getML_COMMENTRule() { + return gaXtype.getML_COMMENTRule(); + } + + //terminal SL_COMMENT: + // '//' !('\n' | '\r')* ('\r'? '\n')?; + public TerminalRule getSL_COMMENTRule() { + return gaXtype.getSL_COMMENTRule(); + } + + //terminal WS: + // ' ' | '\t' | '\r' | '\n'+; + public TerminalRule getWSRule() { + return gaXtype.getWSRule(); + } + + //terminal ANY_OTHER: + // .; + public TerminalRule getANY_OTHERRule() { + return gaXtype.getANY_OTHERRule(); + } +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Command.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Command.java new file mode 100644 index 00000000..801e2db1 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Command.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Command'. + * + * + * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getCommand() + * @model + * @generated + */ +public interface Command extends EObject +{ +} // Command diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Connect.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Connect.java new file mode 100644 index 00000000..53d7b203 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Connect.java @@ -0,0 +1,78 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + + +/** + * + * A representation of the model object 'Connect'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Connect#getFrom From}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Connect#getTo To}
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getConnect() + * @model + * @generated + */ +public interface Connect extends Command +{ + /** + * Returns the value of the 'From' containment reference. + * + *

+ * If the meaning of the 'From' containment reference isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'From' containment reference. + * @see #setFrom(NamedObj) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getConnect_From() + * @model containment="true" + * @generated + */ + NamedObj getFrom(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Connect#getFrom From}' containment reference. + * + * + * @param value the new value of the 'From' containment reference. + * @see #getFrom() + * @generated + */ + void setFrom(NamedObj value); + + /** + * Returns the value of the 'To' containment reference. + * + *

+ * If the meaning of the 'To' containment reference isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'To' containment reference. + * @see #setTo(NamedObj) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getConnect_To() + * @model containment="true" + * @generated + */ + NamedObj getTo(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Connect#getTo To}' containment reference. + * + * + * @param value the new value of the 'To' containment reference. + * @see #getTo() + * @generated + */ + void setTo(NamedObj value); + +} // Connect diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Insert.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Insert.java new file mode 100644 index 00000000..d07e0f5b --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Insert.java @@ -0,0 +1,96 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.common.util.EList; + +/** + * + * A representation of the model object 'Insert'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Insert#getObj Obj}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Insert#getAlias Alias}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Insert#getParameters Parameters}
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getInsert() + * @model + * @generated + */ +public interface Insert extends Command +{ + /** + * Returns the value of the 'Obj' attribute. + * + *

+ * If the meaning of the 'Obj' attribute isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Obj' attribute. + * @see #setObj(String) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getInsert_Obj() + * @model + * @generated + */ + String getObj(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Insert#getObj Obj}' attribute. + * + * + * @param value the new value of the 'Obj' attribute. + * @see #getObj() + * @generated + */ + void setObj(String value); + + /** + * Returns the value of the 'Alias' containment reference. + * + *

+ * If the meaning of the 'Alias' containment reference isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Alias' containment reference. + * @see #setAlias(NamedObj) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getInsert_Alias() + * @model containment="true" + * @generated + */ + NamedObj getAlias(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Insert#getAlias Alias}' containment reference. + * + * + * @param value the new value of the 'Alias' containment reference. + * @see #getAlias() + * @generated + */ + void setAlias(NamedObj value); + + /** + * Returns the value of the 'Parameters' containment reference list. + * The list contents are of type {@link org.eclipse.triquetrum.commands.tqcl.Parameter}. + * + *

+ * If the meaning of the 'Parameters' containment reference list isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Parameters' containment reference list. + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getInsert_Parameters() + * @model containment="true" + * @generated + */ + EList getParameters(); + +} // Insert diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/NamedObj.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/NamedObj.java new file mode 100644 index 00000000..d76e8dda --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/NamedObj.java @@ -0,0 +1,52 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Named Obj'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.NamedObj#getName Name}
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getNamedObj() + * @model + * @generated + */ +public interface NamedObj extends EObject +{ + /** + * Returns the value of the 'Name' attribute. + * + *

+ * If the meaning of the 'Name' attribute isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getNamedObj_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.NamedObj#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // NamedObj diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Parameter.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Parameter.java new file mode 100644 index 00000000..ac2c6633 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/Parameter.java @@ -0,0 +1,79 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Parameter'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Parameter#getName Name}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.Parameter#getValue Value}
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getParameter() + * @model + * @generated + */ +public interface Parameter extends EObject +{ + /** + * Returns the value of the 'Name' attribute. + * + *

+ * If the meaning of the 'Name' attribute isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getParameter_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Parameter#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + + /** + * Returns the value of the 'Value' attribute. + * + *

+ * If the meaning of the 'Value' attribute isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Value' attribute. + * @see #setValue(String) + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getParameter_Value() + * @model + * @generated + */ + String getValue(); + + /** + * Sets the value of the '{@link org.eclipse.triquetrum.commands.tqcl.Parameter#getValue Value}' attribute. + * + * + * @param value the new value of the 'Value' attribute. + * @see #getValue() + * @generated + */ + void setValue(String value); + +} // Parameter diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclFactory.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclFactory.java new file mode 100644 index 00000000..f2c2e6a3 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclFactory.java @@ -0,0 +1,89 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.ecore.EFactory; + +/** + * + * The Factory for the model. + * It provides a create method for each non-abstract class of the model. + * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage + * @generated + */ +public interface TqclFactory extends EFactory +{ + /** + * The singleton instance of the factory. + * + * + * @generated + */ + TqclFactory eINSTANCE = org.eclipse.triquetrum.commands.tqcl.impl.TqclFactoryImpl.init(); + + /** + * Returns a new object of class 'Triquetrum Script'. + * + * + * @return a new object of class 'Triquetrum Script'. + * @generated + */ + TriquetrumScript createTriquetrumScript(); + + /** + * Returns a new object of class 'Command'. + * + * + * @return a new object of class 'Command'. + * @generated + */ + Command createCommand(); + + /** + * Returns a new object of class 'Insert'. + * + * + * @return a new object of class 'Insert'. + * @generated + */ + Insert createInsert(); + + /** + * Returns a new object of class 'Parameter'. + * + * + * @return a new object of class 'Parameter'. + * @generated + */ + Parameter createParameter(); + + /** + * Returns a new object of class 'Named Obj'. + * + * + * @return a new object of class 'Named Obj'. + * @generated + */ + NamedObj createNamedObj(); + + /** + * Returns a new object of class 'Connect'. + * + * + * @return a new object of class 'Connect'. + * @generated + */ + Connect createConnect(); + + /** + * Returns the package supported by this factory. + * + * + * @return the package supported by this factory. + * @generated + */ + TqclPackage getTqclPackage(); + +} //TqclFactory diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclPackage.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclPackage.java new file mode 100644 index 00000000..f086439a --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TqclPackage.java @@ -0,0 +1,572 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +/** + * + * The Package for the model. + * It contains accessors for the meta objects to represent + *
    + *
  • each class,
    • + *
  • each feature of each class,
    • + *
  • each enum,
    • + *
  • and each data type
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclFactory + * @model kind="package" + * @generated + */ +public interface TqclPackage extends EPackage +{ + /** + * The package name. + * + * + * @generated + */ + String eNAME = "tqcl"; + + /** + * The package namespace URI. + * + * + * @generated + */ + String eNS_URI = "http://www.eclipse.org/triquetrum/commands/Tqcl"; + + /** + * The package namespace name. + * + * + * @generated + */ + String eNS_PREFIX = "tqcl"; + + /** + * The singleton instance of the package. + * + * + * @generated + */ + TqclPackage eINSTANCE = org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl.init(); + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.TriquetrumScriptImpl Triquetrum Script}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.TriquetrumScriptImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getTriquetrumScript() + * @generated + */ + int TRIQUETRUM_SCRIPT = 0; + + /** + * The feature id for the 'Commands' containment reference list. + * + * + * @generated + * @ordered + */ + int TRIQUETRUM_SCRIPT__COMMANDS = 0; + + /** + * The number of structural features of the 'Triquetrum Script' class. + * + * + * @generated + * @ordered + */ + int TRIQUETRUM_SCRIPT_FEATURE_COUNT = 1; + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.CommandImpl Command}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.CommandImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getCommand() + * @generated + */ + int COMMAND = 1; + + /** + * The number of structural features of the 'Command' class. + * + * + * @generated + * @ordered + */ + int COMMAND_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl Insert}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getInsert() + * @generated + */ + int INSERT = 2; + + /** + * The feature id for the 'Obj' attribute. + * + * + * @generated + * @ordered + */ + int INSERT__OBJ = COMMAND_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Alias' containment reference. + * + * + * @generated + * @ordered + */ + int INSERT__ALIAS = COMMAND_FEATURE_COUNT + 1; + + /** + * The feature id for the 'Parameters' containment reference list. + * + * + * @generated + * @ordered + */ + int INSERT__PARAMETERS = COMMAND_FEATURE_COUNT + 2; + + /** + * The number of structural features of the 'Insert' class. + * + * + * @generated + * @ordered + */ + int INSERT_FEATURE_COUNT = COMMAND_FEATURE_COUNT + 3; + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl Parameter}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getParameter() + * @generated + */ + int PARAMETER = 3; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int PARAMETER__NAME = 0; + + /** + * The feature id for the 'Value' attribute. + * + * + * @generated + * @ordered + */ + int PARAMETER__VALUE = 1; + + /** + * The number of structural features of the 'Parameter' class. + * + * + * @generated + * @ordered + */ + int PARAMETER_FEATURE_COUNT = 2; + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.NamedObjImpl Named Obj}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.NamedObjImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getNamedObj() + * @generated + */ + int NAMED_OBJ = 4; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int NAMED_OBJ__NAME = 0; + + /** + * The number of structural features of the 'Named Obj' class. + * + * + * @generated + * @ordered + */ + int NAMED_OBJ_FEATURE_COUNT = 1; + + /** + * The meta object id for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl Connect}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getConnect() + * @generated + */ + int CONNECT = 5; + + /** + * The feature id for the 'From' containment reference. + * + * + * @generated + * @ordered + */ + int CONNECT__FROM = COMMAND_FEATURE_COUNT + 0; + + /** + * The feature id for the 'To' containment reference. + * + * + * @generated + * @ordered + */ + int CONNECT__TO = COMMAND_FEATURE_COUNT + 1; + + /** + * The number of structural features of the 'Connect' class. + * + * + * @generated + * @ordered + */ + int CONNECT_FEATURE_COUNT = COMMAND_FEATURE_COUNT + 2; + + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.TriquetrumScript Triquetrum Script}'. + * + * + * @return the meta object for class 'Triquetrum Script'. + * @see org.eclipse.triquetrum.commands.tqcl.TriquetrumScript + * @generated + */ + EClass getTriquetrumScript(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.triquetrum.commands.tqcl.TriquetrumScript#getCommands Commands}'. + * + * + * @return the meta object for the containment reference list 'Commands'. + * @see org.eclipse.triquetrum.commands.tqcl.TriquetrumScript#getCommands() + * @see #getTriquetrumScript() + * @generated + */ + EReference getTriquetrumScript_Commands(); + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.Command Command}'. + * + * + * @return the meta object for class 'Command'. + * @see org.eclipse.triquetrum.commands.tqcl.Command + * @generated + */ + EClass getCommand(); + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.Insert Insert}'. + * + * + * @return the meta object for class 'Insert'. + * @see org.eclipse.triquetrum.commands.tqcl.Insert + * @generated + */ + EClass getInsert(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.triquetrum.commands.tqcl.Insert#getObj Obj}'. + * + * + * @return the meta object for the attribute 'Obj'. + * @see org.eclipse.triquetrum.commands.tqcl.Insert#getObj() + * @see #getInsert() + * @generated + */ + EAttribute getInsert_Obj(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.triquetrum.commands.tqcl.Insert#getAlias Alias}'. + * + * + * @return the meta object for the containment reference 'Alias'. + * @see org.eclipse.triquetrum.commands.tqcl.Insert#getAlias() + * @see #getInsert() + * @generated + */ + EReference getInsert_Alias(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.triquetrum.commands.tqcl.Insert#getParameters Parameters}'. + * + * + * @return the meta object for the containment reference list 'Parameters'. + * @see org.eclipse.triquetrum.commands.tqcl.Insert#getParameters() + * @see #getInsert() + * @generated + */ + EReference getInsert_Parameters(); + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.Parameter Parameter}'. + * + * + * @return the meta object for class 'Parameter'. + * @see org.eclipse.triquetrum.commands.tqcl.Parameter + * @generated + */ + EClass getParameter(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.triquetrum.commands.tqcl.Parameter#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.triquetrum.commands.tqcl.Parameter#getName() + * @see #getParameter() + * @generated + */ + EAttribute getParameter_Name(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.triquetrum.commands.tqcl.Parameter#getValue Value}'. + * + * + * @return the meta object for the attribute 'Value'. + * @see org.eclipse.triquetrum.commands.tqcl.Parameter#getValue() + * @see #getParameter() + * @generated + */ + EAttribute getParameter_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.NamedObj Named Obj}'. + * + * + * @return the meta object for class 'Named Obj'. + * @see org.eclipse.triquetrum.commands.tqcl.NamedObj + * @generated + */ + EClass getNamedObj(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.triquetrum.commands.tqcl.NamedObj#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.triquetrum.commands.tqcl.NamedObj#getName() + * @see #getNamedObj() + * @generated + */ + EAttribute getNamedObj_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.triquetrum.commands.tqcl.Connect Connect}'. + * + * + * @return the meta object for class 'Connect'. + * @see org.eclipse.triquetrum.commands.tqcl.Connect + * @generated + */ + EClass getConnect(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.triquetrum.commands.tqcl.Connect#getFrom From}'. + * + * + * @return the meta object for the containment reference 'From'. + * @see org.eclipse.triquetrum.commands.tqcl.Connect#getFrom() + * @see #getConnect() + * @generated + */ + EReference getConnect_From(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.triquetrum.commands.tqcl.Connect#getTo To}'. + * + * + * @return the meta object for the containment reference 'To'. + * @see org.eclipse.triquetrum.commands.tqcl.Connect#getTo() + * @see #getConnect() + * @generated + */ + EReference getConnect_To(); + + /** + * Returns the factory that creates the instances of the model. + * + * + * @return the factory that creates the instances of the model. + * @generated + */ + TqclFactory getTqclFactory(); + + /** + * + * Defines literals for the meta objects that represent + *
    + *
  • each class,
    • + *
  • each feature of each class,
    • + *
  • each enum,
    • + *
  • and each data type
    • + *
+ * + * @generated + */ + interface Literals + { + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.TriquetrumScriptImpl Triquetrum Script}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.TriquetrumScriptImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getTriquetrumScript() + * @generated + */ + EClass TRIQUETRUM_SCRIPT = eINSTANCE.getTriquetrumScript(); + + /** + * The meta object literal for the 'Commands' containment reference list feature. + * + * + * @generated + */ + EReference TRIQUETRUM_SCRIPT__COMMANDS = eINSTANCE.getTriquetrumScript_Commands(); + + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.CommandImpl Command}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.CommandImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getCommand() + * @generated + */ + EClass COMMAND = eINSTANCE.getCommand(); + + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl Insert}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getInsert() + * @generated + */ + EClass INSERT = eINSTANCE.getInsert(); + + /** + * The meta object literal for the 'Obj' attribute feature. + * + * + * @generated + */ + EAttribute INSERT__OBJ = eINSTANCE.getInsert_Obj(); + + /** + * The meta object literal for the 'Alias' containment reference feature. + * + * + * @generated + */ + EReference INSERT__ALIAS = eINSTANCE.getInsert_Alias(); + + /** + * The meta object literal for the 'Parameters' containment reference list feature. + * + * + * @generated + */ + EReference INSERT__PARAMETERS = eINSTANCE.getInsert_Parameters(); + + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl Parameter}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getParameter() + * @generated + */ + EClass PARAMETER = eINSTANCE.getParameter(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute PARAMETER__NAME = eINSTANCE.getParameter_Name(); + + /** + * The meta object literal for the 'Value' attribute feature. + * + * + * @generated + */ + EAttribute PARAMETER__VALUE = eINSTANCE.getParameter_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.NamedObjImpl Named Obj}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.NamedObjImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getNamedObj() + * @generated + */ + EClass NAMED_OBJ = eINSTANCE.getNamedObj(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute NAMED_OBJ__NAME = eINSTANCE.getNamedObj_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl Connect}' class. + * + * + * @see org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl + * @see org.eclipse.triquetrum.commands.tqcl.impl.TqclPackageImpl#getConnect() + * @generated + */ + EClass CONNECT = eINSTANCE.getConnect(); + + /** + * The meta object literal for the 'From' containment reference feature. + * + * + * @generated + */ + EReference CONNECT__FROM = eINSTANCE.getConnect_From(); + + /** + * The meta object literal for the 'To' containment reference feature. + * + * + * @generated + */ + EReference CONNECT__TO = eINSTANCE.getConnect_To(); + + } + +} //TqclPackage diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TriquetrumScript.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TriquetrumScript.java new file mode 100644 index 00000000..b2ee612a --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/TriquetrumScript.java @@ -0,0 +1,44 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Triquetrum Script'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.TriquetrumScript#getCommands Commands}
    • + *
+ * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getTriquetrumScript() + * @model + * @generated + */ +public interface TriquetrumScript extends EObject +{ + /** + * Returns the value of the 'Commands' containment reference list. + * The list contents are of type {@link org.eclipse.triquetrum.commands.tqcl.Command}. + * + *

+ * If the meaning of the 'Commands' containment reference list isn't clear, + * there really should be more of a description here... + *

+ * + * @return the value of the 'Commands' containment reference list. + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#getTriquetrumScript_Commands() + * @model containment="true" + * @generated + */ + EList getCommands(); + +} // TriquetrumScript diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/CommandImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/CommandImpl.java new file mode 100644 index 00000000..d481e9db --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/CommandImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.triquetrum.commands.tqcl.Command; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; + +/** + * + * An implementation of the model object 'Command'. + * + * + * @generated + */ +public class CommandImpl extends MinimalEObjectImpl.Container implements Command +{ + /** + * + * + * @generated + */ + protected CommandImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.COMMAND; + } + +} //CommandImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ConnectImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ConnectImpl.java new file mode 100644 index 00000000..4375acd2 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ConnectImpl.java @@ -0,0 +1,265 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.triquetrum.commands.tqcl.Connect; +import org.eclipse.triquetrum.commands.tqcl.NamedObj; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; + +/** + * + * An implementation of the model object 'Connect'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl#getFrom From}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.ConnectImpl#getTo To}
    • + *
+ * + * @generated + */ +public class ConnectImpl extends CommandImpl implements Connect +{ + /** + * The cached value of the '{@link #getFrom() From}' containment reference. + * + * + * @see #getFrom() + * @generated + * @ordered + */ + protected NamedObj from; + + /** + * The cached value of the '{@link #getTo() To}' containment reference. + * + * + * @see #getTo() + * @generated + * @ordered + */ + protected NamedObj to; + + /** + * + * + * @generated + */ + protected ConnectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.CONNECT; + } + + /** + * + * + * @generated + */ + public NamedObj getFrom() + { + return from; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetFrom(NamedObj newFrom, NotificationChain msgs) + { + NamedObj oldFrom = from; + from = newFrom; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, TqclPackage.CONNECT__FROM, oldFrom, newFrom); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setFrom(NamedObj newFrom) + { + if (newFrom != from) + { + NotificationChain msgs = null; + if (from != null) + msgs = ((InternalEObject)from).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - TqclPackage.CONNECT__FROM, null, msgs); + if (newFrom != null) + msgs = ((InternalEObject)newFrom).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - TqclPackage.CONNECT__FROM, null, msgs); + msgs = basicSetFrom(newFrom, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.CONNECT__FROM, newFrom, newFrom)); + } + + /** + * + * + * @generated + */ + public NamedObj getTo() + { + return to; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTo(NamedObj newTo, NotificationChain msgs) + { + NamedObj oldTo = to; + to = newTo; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, TqclPackage.CONNECT__TO, oldTo, newTo); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setTo(NamedObj newTo) + { + if (newTo != to) + { + NotificationChain msgs = null; + if (to != null) + msgs = ((InternalEObject)to).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - TqclPackage.CONNECT__TO, null, msgs); + if (newTo != null) + msgs = ((InternalEObject)newTo).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - TqclPackage.CONNECT__TO, null, msgs); + msgs = basicSetTo(newTo, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.CONNECT__TO, newTo, newTo)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case TqclPackage.CONNECT__FROM: + return basicSetFrom(null, msgs); + case TqclPackage.CONNECT__TO: + return basicSetTo(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case TqclPackage.CONNECT__FROM: + return getFrom(); + case TqclPackage.CONNECT__TO: + return getTo(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case TqclPackage.CONNECT__FROM: + setFrom((NamedObj)newValue); + return; + case TqclPackage.CONNECT__TO: + setTo((NamedObj)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case TqclPackage.CONNECT__FROM: + setFrom((NamedObj)null); + return; + case TqclPackage.CONNECT__TO: + setTo((NamedObj)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case TqclPackage.CONNECT__FROM: + return from != null; + case TqclPackage.CONNECT__TO: + return to != null; + } + return super.eIsSet(featureID); + } + +} //ConnectImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/InsertImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/InsertImpl.java new file mode 100644 index 00000000..6801086a --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/InsertImpl.java @@ -0,0 +1,312 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.triquetrum.commands.tqcl.Insert; +import org.eclipse.triquetrum.commands.tqcl.NamedObj; +import org.eclipse.triquetrum.commands.tqcl.Parameter; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; + +/** + * + * An implementation of the model object 'Insert'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl#getObj Obj}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl#getAlias Alias}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.InsertImpl#getParameters Parameters}
    • + *
+ * + * @generated + */ +public class InsertImpl extends CommandImpl implements Insert +{ + /** + * The default value of the '{@link #getObj() Obj}' attribute. + * + * + * @see #getObj() + * @generated + * @ordered + */ + protected static final String OBJ_EDEFAULT = null; + + /** + * The cached value of the '{@link #getObj() Obj}' attribute. + * + * + * @see #getObj() + * @generated + * @ordered + */ + protected String obj = OBJ_EDEFAULT; + + /** + * The cached value of the '{@link #getAlias() Alias}' containment reference. + * + * + * @see #getAlias() + * @generated + * @ordered + */ + protected NamedObj alias; + + /** + * The cached value of the '{@link #getParameters() Parameters}' containment reference list. + * + * + * @see #getParameters() + * @generated + * @ordered + */ + protected EList parameters; + + /** + * + * + * @generated + */ + protected InsertImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.INSERT; + } + + /** + * + * + * @generated + */ + public String getObj() + { + return obj; + } + + /** + * + * + * @generated + */ + public void setObj(String newObj) + { + String oldObj = obj; + obj = newObj; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.INSERT__OBJ, oldObj, obj)); + } + + /** + * + * + * @generated + */ + public NamedObj getAlias() + { + return alias; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetAlias(NamedObj newAlias, NotificationChain msgs) + { + NamedObj oldAlias = alias; + alias = newAlias; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, TqclPackage.INSERT__ALIAS, oldAlias, newAlias); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + public void setAlias(NamedObj newAlias) + { + if (newAlias != alias) + { + NotificationChain msgs = null; + if (alias != null) + msgs = ((InternalEObject)alias).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - TqclPackage.INSERT__ALIAS, null, msgs); + if (newAlias != null) + msgs = ((InternalEObject)newAlias).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - TqclPackage.INSERT__ALIAS, null, msgs); + msgs = basicSetAlias(newAlias, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.INSERT__ALIAS, newAlias, newAlias)); + } + + /** + * + * + * @generated + */ + public EList getParameters() + { + if (parameters == null) + { + parameters = new EObjectContainmentEList(Parameter.class, this, TqclPackage.INSERT__PARAMETERS); + } + return parameters; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case TqclPackage.INSERT__ALIAS: + return basicSetAlias(null, msgs); + case TqclPackage.INSERT__PARAMETERS: + return ((InternalEList)getParameters()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case TqclPackage.INSERT__OBJ: + return getObj(); + case TqclPackage.INSERT__ALIAS: + return getAlias(); + case TqclPackage.INSERT__PARAMETERS: + return getParameters(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case TqclPackage.INSERT__OBJ: + setObj((String)newValue); + return; + case TqclPackage.INSERT__ALIAS: + setAlias((NamedObj)newValue); + return; + case TqclPackage.INSERT__PARAMETERS: + getParameters().clear(); + getParameters().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case TqclPackage.INSERT__OBJ: + setObj(OBJ_EDEFAULT); + return; + case TqclPackage.INSERT__ALIAS: + setAlias((NamedObj)null); + return; + case TqclPackage.INSERT__PARAMETERS: + getParameters().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case TqclPackage.INSERT__OBJ: + return OBJ_EDEFAULT == null ? obj != null : !OBJ_EDEFAULT.equals(obj); + case TqclPackage.INSERT__ALIAS: + return alias != null; + case TqclPackage.INSERT__PARAMETERS: + return parameters != null && !parameters.isEmpty(); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (obj: "); + result.append(obj); + result.append(')'); + return result.toString(); + } + +} //InsertImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/NamedObjImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/NamedObjImpl.java new file mode 100644 index 00000000..b5c0e284 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/NamedObjImpl.java @@ -0,0 +1,178 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.triquetrum.commands.tqcl.NamedObj; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; + +/** + * + * An implementation of the model object 'Named Obj'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.NamedObjImpl#getName Name}
    • + *
+ * + * @generated + */ +public class NamedObjImpl extends MinimalEObjectImpl.Container implements NamedObj +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected NamedObjImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.NAMED_OBJ; + } + + /** + * + * + * @generated + */ + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.NAMED_OBJ__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case TqclPackage.NAMED_OBJ__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case TqclPackage.NAMED_OBJ__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case TqclPackage.NAMED_OBJ__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case TqclPackage.NAMED_OBJ__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //NamedObjImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ParameterImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ParameterImpl.java new file mode 100644 index 00000000..5776f907 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/ParameterImpl.java @@ -0,0 +1,234 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.triquetrum.commands.tqcl.Parameter; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; + +/** + * + * An implementation of the model object 'Parameter'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl#getName Name}
    • + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.ParameterImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class ParameterImpl extends MinimalEObjectImpl.Container implements Parameter +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * The default value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected static final String VALUE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected String value = VALUE_EDEFAULT; + + /** + * + * + * @generated + */ + protected ParameterImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.PARAMETER; + } + + /** + * + * + * @generated + */ + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.PARAMETER__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + public String getValue() + { + return value; + } + + /** + * + * + * @generated + */ + public void setValue(String newValue) + { + String oldValue = value; + value = newValue; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, TqclPackage.PARAMETER__VALUE, oldValue, value)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case TqclPackage.PARAMETER__NAME: + return getName(); + case TqclPackage.PARAMETER__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case TqclPackage.PARAMETER__NAME: + setName((String)newValue); + return; + case TqclPackage.PARAMETER__VALUE: + setValue((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case TqclPackage.PARAMETER__NAME: + setName(NAME_EDEFAULT); + return; + case TqclPackage.PARAMETER__VALUE: + setValue(VALUE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case TqclPackage.PARAMETER__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + case TqclPackage.PARAMETER__VALUE: + return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(", value: "); + result.append(value); + result.append(')'); + return result.toString(); + } + +} //ParameterImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclFactoryImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclFactoryImpl.java new file mode 100644 index 00000000..a1835b09 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclFactoryImpl.java @@ -0,0 +1,167 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.impl.EFactoryImpl; + +import org.eclipse.emf.ecore.plugin.EcorePlugin; + +import org.eclipse.triquetrum.commands.tqcl.*; + +/** + * + * An implementation of the model Factory. + * + * @generated + */ +public class TqclFactoryImpl extends EFactoryImpl implements TqclFactory +{ + /** + * Creates the default factory implementation. + * + * + * @generated + */ + public static TqclFactory init() + { + try + { + TqclFactory theTqclFactory = (TqclFactory)EPackage.Registry.INSTANCE.getEFactory(TqclPackage.eNS_URI); + if (theTqclFactory != null) + { + return theTqclFactory; + } + } + catch (Exception exception) + { + EcorePlugin.INSTANCE.log(exception); + } + return new TqclFactoryImpl(); + } + + /** + * Creates an instance of the factory. + * + * + * @generated + */ + public TqclFactoryImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + public EObject create(EClass eClass) + { + switch (eClass.getClassifierID()) + { + case TqclPackage.TRIQUETRUM_SCRIPT: return createTriquetrumScript(); + case TqclPackage.COMMAND: return createCommand(); + case TqclPackage.INSERT: return createInsert(); + case TqclPackage.PARAMETER: return createParameter(); + case TqclPackage.NAMED_OBJ: return createNamedObj(); + case TqclPackage.CONNECT: return createConnect(); + default: + throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + public TriquetrumScript createTriquetrumScript() + { + TriquetrumScriptImpl triquetrumScript = new TriquetrumScriptImpl(); + return triquetrumScript; + } + + /** + * + * + * @generated + */ + public Command createCommand() + { + CommandImpl command = new CommandImpl(); + return command; + } + + /** + * + * + * @generated + */ + public Insert createInsert() + { + InsertImpl insert = new InsertImpl(); + return insert; + } + + /** + * + * + * @generated + */ + public Parameter createParameter() + { + ParameterImpl parameter = new ParameterImpl(); + return parameter; + } + + /** + * + * + * @generated + */ + public NamedObj createNamedObj() + { + NamedObjImpl namedObj = new NamedObjImpl(); + return namedObj; + } + + /** + * + * + * @generated + */ + public Connect createConnect() + { + ConnectImpl connect = new ConnectImpl(); + return connect; + } + + /** + * + * + * @generated + */ + public TqclPackage getTqclPackage() + { + return (TqclPackage)getEPackage(); + } + + /** + * + * + * @deprecated + * @generated + */ + @Deprecated + public static TqclPackage getPackage() + { + return TqclPackage.eINSTANCE; + } + +} //TqclFactoryImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclPackageImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclPackageImpl.java new file mode 100644 index 00000000..30085066 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TqclPackageImpl.java @@ -0,0 +1,395 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +import org.eclipse.emf.ecore.impl.EPackageImpl; + +import org.eclipse.triquetrum.commands.tqcl.Command; +import org.eclipse.triquetrum.commands.tqcl.Connect; +import org.eclipse.triquetrum.commands.tqcl.Insert; +import org.eclipse.triquetrum.commands.tqcl.NamedObj; +import org.eclipse.triquetrum.commands.tqcl.Parameter; +import org.eclipse.triquetrum.commands.tqcl.TqclFactory; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; +import org.eclipse.triquetrum.commands.tqcl.TriquetrumScript; + +/** + * + * An implementation of the model Package. + * + * @generated + */ +public class TqclPackageImpl extends EPackageImpl implements TqclPackage +{ + /** + * + * + * @generated + */ + private EClass triquetrumScriptEClass = null; + + /** + * + * + * @generated + */ + private EClass commandEClass = null; + + /** + * + * + * @generated + */ + private EClass insertEClass = null; + + /** + * + * + * @generated + */ + private EClass parameterEClass = null; + + /** + * + * + * @generated + */ + private EClass namedObjEClass = null; + + /** + * + * + * @generated + */ + private EClass connectEClass = null; + + /** + * Creates an instance of the model Package, registered with + * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package + * package URI value. + *

Note: the correct way to create the package is via the static + * factory method {@link #init init()}, which also performs + * initialization of the package, or returns the registered package, + * if one already exists. + * + * + * @see org.eclipse.emf.ecore.EPackage.Registry + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage#eNS_URI + * @see #init() + * @generated + */ + private TqclPackageImpl() + { + super(eNS_URI, TqclFactory.eINSTANCE); + } + + /** + * + * + * @generated + */ + private static boolean isInited = false; + + /** + * Creates, registers, and initializes the Package for this model, and for any others upon which it depends. + * + *

This method is used to initialize {@link TqclPackage#eINSTANCE} when that field is accessed. + * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package. + * + * + * @see #eNS_URI + * @see #createPackageContents() + * @see #initializePackageContents() + * @generated + */ + public static TqclPackage init() + { + if (isInited) return (TqclPackage)EPackage.Registry.INSTANCE.getEPackage(TqclPackage.eNS_URI); + + // Obtain or create and register package + TqclPackageImpl theTqclPackage = (TqclPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof TqclPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new TqclPackageImpl()); + + isInited = true; + + // Create package meta-data objects + theTqclPackage.createPackageContents(); + + // Initialize created meta-data + theTqclPackage.initializePackageContents(); + + // Mark meta-data to indicate it can't be changed + theTqclPackage.freeze(); + + + // Update the registry and return the package + EPackage.Registry.INSTANCE.put(TqclPackage.eNS_URI, theTqclPackage); + return theTqclPackage; + } + + /** + * + * + * @generated + */ + public EClass getTriquetrumScript() + { + return triquetrumScriptEClass; + } + + /** + * + * + * @generated + */ + public EReference getTriquetrumScript_Commands() + { + return (EReference)triquetrumScriptEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getCommand() + { + return commandEClass; + } + + /** + * + * + * @generated + */ + public EClass getInsert() + { + return insertEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getInsert_Obj() + { + return (EAttribute)insertEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getInsert_Alias() + { + return (EReference)insertEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getInsert_Parameters() + { + return (EReference)insertEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getParameter() + { + return parameterEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getParameter_Name() + { + return (EAttribute)parameterEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EAttribute getParameter_Value() + { + return (EAttribute)parameterEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getNamedObj() + { + return namedObjEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getNamedObj_Name() + { + return (EAttribute)namedObjEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getConnect() + { + return connectEClass; + } + + /** + * + * + * @generated + */ + public EReference getConnect_From() + { + return (EReference)connectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getConnect_To() + { + return (EReference)connectEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public TqclFactory getTqclFactory() + { + return (TqclFactory)getEFactoryInstance(); + } + + /** + * + * + * @generated + */ + private boolean isCreated = false; + + /** + * Creates the meta-model objects for the package. This method is + * guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void createPackageContents() + { + if (isCreated) return; + isCreated = true; + + // Create classes and their features + triquetrumScriptEClass = createEClass(TRIQUETRUM_SCRIPT); + createEReference(triquetrumScriptEClass, TRIQUETRUM_SCRIPT__COMMANDS); + + commandEClass = createEClass(COMMAND); + + insertEClass = createEClass(INSERT); + createEAttribute(insertEClass, INSERT__OBJ); + createEReference(insertEClass, INSERT__ALIAS); + createEReference(insertEClass, INSERT__PARAMETERS); + + parameterEClass = createEClass(PARAMETER); + createEAttribute(parameterEClass, PARAMETER__NAME); + createEAttribute(parameterEClass, PARAMETER__VALUE); + + namedObjEClass = createEClass(NAMED_OBJ); + createEAttribute(namedObjEClass, NAMED_OBJ__NAME); + + connectEClass = createEClass(CONNECT); + createEReference(connectEClass, CONNECT__FROM); + createEReference(connectEClass, CONNECT__TO); + } + + /** + * + * + * @generated + */ + private boolean isInitialized = false; + + /** + * Complete the initialization of the package and its meta-model. This + * method is guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void initializePackageContents() + { + if (isInitialized) return; + isInitialized = true; + + // Initialize package + setName(eNAME); + setNsPrefix(eNS_PREFIX); + setNsURI(eNS_URI); + + // Create type parameters + + // Set bounds for type parameters + + // Add supertypes to classes + insertEClass.getESuperTypes().add(this.getCommand()); + connectEClass.getESuperTypes().add(this.getCommand()); + + // Initialize classes and features; add operations and parameters + initEClass(triquetrumScriptEClass, TriquetrumScript.class, "TriquetrumScript", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getTriquetrumScript_Commands(), this.getCommand(), null, "commands", null, 0, -1, TriquetrumScript.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(commandEClass, Command.class, "Command", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(insertEClass, Insert.class, "Insert", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getInsert_Obj(), ecorePackage.getEString(), "obj", null, 0, 1, Insert.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getInsert_Alias(), this.getNamedObj(), null, "alias", null, 0, 1, Insert.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getInsert_Parameters(), this.getParameter(), null, "parameters", null, 0, -1, Insert.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(parameterEClass, Parameter.class, "Parameter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getParameter_Name(), ecorePackage.getEString(), "name", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getParameter_Value(), ecorePackage.getEString(), "value", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(namedObjEClass, NamedObj.class, "NamedObj", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getNamedObj_Name(), ecorePackage.getEString(), "name", null, 0, 1, NamedObj.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(connectEClass, Connect.class, "Connect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getConnect_From(), this.getNamedObj(), null, "from", null, 0, 1, Connect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConnect_To(), this.getNamedObj(), null, "to", null, 0, 1, Connect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + // Create resource + createResource(eNS_URI); + } + +} //TqclPackageImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TriquetrumScriptImpl.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TriquetrumScriptImpl.java new file mode 100644 index 00000000..e4a0b2ce --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/impl/TriquetrumScriptImpl.java @@ -0,0 +1,168 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.triquetrum.commands.tqcl.Command; +import org.eclipse.triquetrum.commands.tqcl.TqclPackage; +import org.eclipse.triquetrum.commands.tqcl.TriquetrumScript; + +/** + * + * An implementation of the model object 'Triquetrum Script'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.triquetrum.commands.tqcl.impl.TriquetrumScriptImpl#getCommands Commands}
    • + *
+ * + * @generated + */ +public class TriquetrumScriptImpl extends MinimalEObjectImpl.Container implements TriquetrumScript +{ + /** + * The cached value of the '{@link #getCommands() Commands}' containment reference list. + * + * + * @see #getCommands() + * @generated + * @ordered + */ + protected EList commands; + + /** + * + * + * @generated + */ + protected TriquetrumScriptImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return TqclPackage.Literals.TRIQUETRUM_SCRIPT; + } + + /** + * + * + * @generated + */ + public EList getCommands() + { + if (commands == null) + { + commands = new EObjectContainmentEList(Command.class, this, TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS); + } + return commands; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS: + return ((InternalEList)getCommands()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS: + return getCommands(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS: + getCommands().clear(); + getCommands().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS: + getCommands().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case TqclPackage.TRIQUETRUM_SCRIPT__COMMANDS: + return commands != null && !commands.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //TriquetrumScriptImpl diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclAdapterFactory.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclAdapterFactory.java new file mode 100644 index 00000000..ba4f78d1 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclAdapterFactory.java @@ -0,0 +1,233 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.util; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; + +import org.eclipse.emf.ecore.EObject; + +import org.eclipse.triquetrum.commands.tqcl.*; + +/** + * + * The Adapter Factory for the model. + * It provides an adapter createXXX method for each class of the model. + * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage + * @generated + */ +public class TqclAdapterFactory extends AdapterFactoryImpl +{ + /** + * The cached model package. + * + * + * @generated + */ + protected static TqclPackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public TqclAdapterFactory() + { + if (modelPackage == null) + { + modelPackage = TqclPackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * + * This implementation returns true if the object is either the model's package or is an instance object of the model. + * + * @return whether this factory is applicable for the type of the object. + * @generated + */ + @Override + public boolean isFactoryForType(Object object) + { + if (object == modelPackage) + { + return true; + } + if (object instanceof EObject) + { + return ((EObject)object).eClass().getEPackage() == modelPackage; + } + return false; + } + + /** + * The switch that delegates to the createXXX methods. + * + * + * @generated + */ + protected TqclSwitch modelSwitch = + new TqclSwitch() + { + @Override + public Adapter caseTriquetrumScript(TriquetrumScript object) + { + return createTriquetrumScriptAdapter(); + } + @Override + public Adapter caseCommand(Command object) + { + return createCommandAdapter(); + } + @Override + public Adapter caseInsert(Insert object) + { + return createInsertAdapter(); + } + @Override + public Adapter caseParameter(Parameter object) + { + return createParameterAdapter(); + } + @Override + public Adapter caseNamedObj(NamedObj object) + { + return createNamedObjAdapter(); + } + @Override + public Adapter caseConnect(Connect object) + { + return createConnectAdapter(); + } + @Override + public Adapter defaultCase(EObject object) + { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the target. + * + * + * @param target the object to adapt. + * @return the adapter for the target. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) + { + return modelSwitch.doSwitch((EObject)target); + } + + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.TriquetrumScript Triquetrum Script}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.TriquetrumScript + * @generated + */ + public Adapter createTriquetrumScriptAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.Command Command}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.Command + * @generated + */ + public Adapter createCommandAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.Insert Insert}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.Insert + * @generated + */ + public Adapter createInsertAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.Parameter Parameter}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.Parameter + * @generated + */ + public Adapter createParameterAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.NamedObj Named Obj}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.NamedObj + * @generated + */ + public Adapter createNamedObjAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.triquetrum.commands.tqcl.Connect Connect}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.triquetrum.commands.tqcl.Connect + * @generated + */ + public Adapter createConnectAdapter() + { + return null; + } + + /** + * Creates a new adapter for the default case. + * + * This default implementation returns null. + * + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() + { + return null; + } + +} //TqclAdapterFactory diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclSwitch.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclSwitch.java new file mode 100644 index 00000000..25f7efdf --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/tqcl/util/TqclSwitch.java @@ -0,0 +1,237 @@ +/** + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.tqcl.util; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.util.Switch; + +import org.eclipse.triquetrum.commands.tqcl.*; + +/** + * + * The Switch for the model's inheritance hierarchy. + * It supports the call {@link #doSwitch(EObject) doSwitch(object)} + * to invoke the caseXXX method for each class of the model, + * starting with the actual class of the object + * and proceeding up the inheritance hierarchy + * until a non-null result is returned, + * which is the result of the switch. + * + * @see org.eclipse.triquetrum.commands.tqcl.TqclPackage + * @generated + */ +public class TqclSwitch extends Switch +{ + /** + * The cached model package + * + * + * @generated + */ + protected static TqclPackage modelPackage; + + /** + * Creates an instance of the switch. + * + * + * @generated + */ + public TqclSwitch() + { + if (modelPackage == null) + { + modelPackage = TqclPackage.eINSTANCE; + } + } + + /** + * Checks whether this is a switch for the given package. + * + * + * @param ePackage the package in question. + * @return whether this is a switch for the given package. + * @generated + */ + @Override + protected boolean isSwitchFor(EPackage ePackage) + { + return ePackage == modelPackage; + } + + /** + * Calls caseXXX for each class of the model until one returns a non null result; it yields that result. + * + * + * @return the first non-null result returned by a caseXXX call. + * @generated + */ + @Override + protected T doSwitch(int classifierID, EObject theEObject) + { + switch (classifierID) + { + case TqclPackage.TRIQUETRUM_SCRIPT: + { + TriquetrumScript triquetrumScript = (TriquetrumScript)theEObject; + T result = caseTriquetrumScript(triquetrumScript); + if (result == null) result = defaultCase(theEObject); + return result; + } + case TqclPackage.COMMAND: + { + Command command = (Command)theEObject; + T result = caseCommand(command); + if (result == null) result = defaultCase(theEObject); + return result; + } + case TqclPackage.INSERT: + { + Insert insert = (Insert)theEObject; + T result = caseInsert(insert); + if (result == null) result = caseCommand(insert); + if (result == null) result = defaultCase(theEObject); + return result; + } + case TqclPackage.PARAMETER: + { + Parameter parameter = (Parameter)theEObject; + T result = caseParameter(parameter); + if (result == null) result = defaultCase(theEObject); + return result; + } + case TqclPackage.NAMED_OBJ: + { + NamedObj namedObj = (NamedObj)theEObject; + T result = caseNamedObj(namedObj); + if (result == null) result = defaultCase(theEObject); + return result; + } + case TqclPackage.CONNECT: + { + Connect connect = (Connect)theEObject; + T result = caseConnect(connect); + if (result == null) result = caseCommand(connect); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of 'Triquetrum Script'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Triquetrum Script'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTriquetrumScript(TriquetrumScript object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Command'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Command'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseCommand(Command object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Insert'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Insert'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseInsert(Insert object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Parameter'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Parameter'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseParameter(Parameter object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Named Obj'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Named Obj'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNamedObj(NamedObj object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Connect'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Connect'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConnect(Connect object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'EObject'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch, but this is the last case anyway. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'EObject'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) + * @generated + */ + @Override + public T defaultCase(EObject object) + { + return null; + } + +} //TqclSwitch diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/validation/AbstractTqclValidator.java b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/validation/AbstractTqclValidator.java new file mode 100644 index 00000000..711abcf4 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java-gen/org/eclipse/triquetrum/commands/validation/AbstractTqclValidator.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.validation; + +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.xtext.xbase.validation.XtypeValidator; + +public abstract class AbstractTqclValidator extends XtypeValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(super.getEPackages()); + result.add(org.eclipse.triquetrum.commands.tqcl.TqclPackage.eINSTANCE); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype")); + return result; + } + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/GenerateTqcl.mwe2 b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/GenerateTqcl.mwe2 index baab4620..f7bfbd92 100644 --- a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/GenerateTqcl.mwe2 +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/GenerateTqcl.mwe2 @@ -7,32 +7,46 @@ var rootPath = ".." Workflow { +// component = org.eclipse.emf.mwe.utils.DirectoryCleaner +// { +// directory = "" +// } component = XtextGenerator { + cleaner = { + enabled = true + } + configuration = { project = StandardProjectConfig { baseName = "org.eclipse.triquetrum.commands.xtext" rootPath = rootPath runtimeTest = { + enabled = false src = "src/test/java" - srcGen="src/test/java-gen" - + srcGen = "src/test/java-gen" } - runtime = - { + runtime = { src = "src/main/java" - srcGen="src/main/java-gen" + srcGen = "src/main/java-gen" } eclipsePlugin = { - enabled = true + name = ".ui" + enabled = false src = "src/main/java" - srcGen="src/main/java-gen" + srcGen = "src/main/java-gen" } - + eclipsePluginTest = { - enabled = true + enabled = false src = "src/test/java" - srcGen="src/test/java-gen" + srcGen = "src/test/java-gen" } + genericIde = { + name = ".ide" + src = "src/main/java" + srcGen = "src/main/java-gen" + } + createEclipseMetaData = true } @@ -45,8 +59,14 @@ Workflow { language = StandardLanguage { name = "org.eclipse.triquetrum.commands.Tqcl" fileExtensions = "tdcl" + emfGenerator = { + javaModelDirectory = "org.eclipse.triquetrum.commands.xtext/src/main/java-gen" + } + + generator = generator.GeneratorFragment2 { generateStub = true + generateXtendStub = false } serializer = { @@ -64,6 +84,9 @@ Workflow { generateStub = true generateXtendStub = false } + + + } } } diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclRuntimeModule.xtend b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclRuntimeModule.xtend new file mode 100644 index 00000000..0ffcc113 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclRuntimeModule.xtend @@ -0,0 +1,11 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands + + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +class TqclRuntimeModule extends AbstractTqclRuntimeModule { +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclStandaloneSetup.xtend b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclStandaloneSetup.xtend new file mode 100644 index 00000000..3034945f --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/TqclStandaloneSetup.xtend @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands + + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +class TqclStandaloneSetup extends TqclStandaloneSetupGenerated { + + def static void doSetup() { + new TqclStandaloneSetup().createInjectorAndDoEMFRegistration() + } +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/generator/TqclGenerator.java b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/generator/TqclGenerator.java new file mode 100644 index 00000000..52b86652 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/generator/TqclGenerator.java @@ -0,0 +1,30 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.generator; + +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.generator.AbstractGenerator; +import org.eclipse.xtext.generator.IFileSystemAccess2; +import org.eclipse.xtext.generator.IGeneratorContext; + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +public class TqclGenerator extends AbstractGenerator { + + @Override + public void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { +// Iterator filtered = Iterators.filter(resource.getAllContents(), Greeting.class); +// Iterator names = Iterators.transform(filtered, new Function() { +// +// @Override +// public String apply(Greeting greeting) { +// return greeting.getName(); +// } +// }); +// fsa.generateFile("greetings.txt", "People to greet: " + IteratorExtensions.join(names, ", ")); + } +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/scoping/TqclScopeProvider.java b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/scoping/TqclScopeProvider.java new file mode 100644 index 00000000..af755a20 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/scoping/TqclScopeProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.scoping; + + +/** + * This class contains custom scoping description. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping + * on how and when to use it. + */ +public class TqclScopeProvider extends AbstractTqclScopeProvider { + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSemanticSequencer.java b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSemanticSequencer.java new file mode 100644 index 00000000..56f4fd2a --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSemanticSequencer.java @@ -0,0 +1,8 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.serializer; + + +public class TqclSemanticSequencer extends AbstractTqclSemanticSequencer { +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSyntacticSequencer.java b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSyntacticSequencer.java new file mode 100644 index 00000000..f81bc41d --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/serializer/TqclSyntacticSequencer.java @@ -0,0 +1,8 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.serializer; + + +public class TqclSyntacticSequencer extends AbstractTqclSyntacticSequencer { +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/validation/TqclValidator.java b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/validation/TqclValidator.java new file mode 100644 index 00000000..0de0f569 --- /dev/null +++ b/org.eclipse.triquetrum.commands.xtext/src/main/java/org/eclipse/triquetrum/commands/validation/TqclValidator.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.10.0 + */ +package org.eclipse.triquetrum.commands.validation; + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +public class TqclValidator extends AbstractTqclValidator { + +// public static final INVALID_NAME = 'invalidName' +// +// @Check +// public void checkGreetingStartsWithCapital(Greeting greeting) { +// if (!Character.isUpperCase(greeting.getName().charAt(0))) { +// warning("Name should start with a capital", +// TqclPackage.Literals.GREETING__NAME, +// INVALID_NAME); +// } +// } + +} diff --git a/org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/.TqclRuntimeModule.xtendbin b/org.eclipse.triquetrum.commands.xtext/src/main/xtend-gen/org/eclipse/triquetrum/commands/.TqclRuntimeModule.xtendbin new file mode 100644 index 0000000000000000000000000000000000000000..e7749744fd7c5da24eeae67e023f9be9ad254874 GIT binary patch literal 1649 zcmaJ>dpHwn9G=TE_hF<(LrxiUd5owiqpaE^i>+L9Yim>6WQ0fzxnCo!gsc*BYp%sH z+KI>|RM_MZQWR~KqneKWm3q!O@At>|eSdtv@B7~0`@UF=lr#hY0)YTZ_p=TIHb7y0 zO`s5s18CF`0yTtQb(TC8BWsKXP(=T_SatzH*n(<3u)tmrv*_saUW<-ZZG+QixSjH8HW3r)eF z=3lupuT0{<2~mc=|#aC>m;`YU!QQGoeXQQ*-*#_fB z*yX+}Q6A;Pj%8I-FVmnvzKQgO&BIn<`RtB|W_UtKv_5fK5RUJQGo6_k9je;%5s#1Y zomB?q-RRUr%uBj4)(WuWE47&=wk(o_%EXV5_Yq$NHC<;624_zajgyZb-D)?1bFYL) zA;&m_rRu=7p{2=7uhR5X+nYU8rym%^zH%6CJqqWK^>q&^5u7j5WEKWn!MUySbxlpyWubkdyETQwrUmM`79s15dXDy{Q%s zS3`+LSVXRzNKN$)^6d=PFuAwChdVKl7^fdvU!fkgx{yJ+Q+=0HeZB-Oi(zE9QGui2 zsxmk~aOb{dr3e{$i!U4~#V<3Ax?|Y>Ly^)L%*T4lIy+Ppfn}%w zkaDb*lB1VSlM()gu;o!Qc@PP>w4cJ-CBJRk72yZI*%(1XB#FhyfXYulv=m4H0P4~J z0QNt%0$JBeFo8}B4Gtg}pCZr$g2_Q4WEz$0VoOs)fwdpMp(l|LAXT6wTy&4FX>`~j zE9tNvg5|4=;(n!4Y8t{KCyRvME(cN`6_-rGu)})sdVvP3Qn-<%j5g)h2AqS>YPlZ* zErgQ~t%PekN7#%EoI_#+1I^qGuZL)J*=c!?uP4EuTGkJKFGh0jPNCVRFHwcd1!U)s zpcVzu2|f%Ky%Oy$bEs@aQ47tOwyW?>?VIX$-+_x#MdHp)g`0y&^9zh3(rk8&AS>-{ zF42-zr7MJ*SL(JU?^K!wM|8A4%RE@E`$?k2|IvFd6tDmOT0um(g@S3+UWS)FEU<}qLQQE<1?;MUD5+Sb?A#?PbziE%>P1qmWaF@pWs-YkB0ENnL++D zoe?aEZB!udkaIgf;#)#{r9D9z@ify7y2bQNavmRqcVJ*m;VQ@HE^bE*>_L;f=4~z0 z(s#c$87(tO5B$7TyzkWoQG*;t+f60stMx2A)0(4Y5scH_X)xQ@ zQKi*q?z;oV*>+?%WK-{)Un6>s-tMn^(HK^oOuBuWhs?&0zbH@pqsu?!O=-n$oI2-8 zm1Sm0X)K%2-X*lzJ8*xq>o~W+06?6G4SI1}3M!9yz53+)L=2|8#hr0dgFNI#9awC! zF8-t}mfFE;ff8I20GRq;sflCBk4~orkp098qk9Uk#x^u3q0Efx5XWlR`bhM^_B!h> ztGbvx(Q{6hzwGA1Ed@Ny=3s%ED^K+bMv!W=#TsLt;*yFK&|M7W7PU3)V(P9-9bgow za}yLo6%??t#9C>2Ffz{!G{1FzFD{ogcPk#J!O~dR;_IPx-J`zuR_Hsn_JmVGEKxmI z2xySAQoDrx0QS=X4?ay_I+d^$T=G`C}&I?2@9b_c@(PlfXe@+t5%okV~W+{E~h zF{7fUV>XbOWwv#ftDSwHx=xOKz6BciGPXJNgxF{@AaHN>`H}U%Mz5O>i;<9o0Di{w zMpKIU_!S#N`}dO@IToAtClKq*|C@z>udwl5zuuj{-nWgN!D4`$#Py}tN8|c@3nq+)=k8 z^`WeUuO&Ng&zFLDf{TGHTq=1rgIV1WWHDF%#c}xV^H_ncdg19g%xuUddo4w7Mv2wU z7c)gV>5$5m0Wa%QL$#X^(Px?q8|@xFM?Hpxp+hKqCybwA+NG0_*$X$H;Q zMegsgW%q->G{V+Q`lAd{pkluSjxDW&5Gx$XO#SxYVO=U$q!!g7csb!39rnna%wdxCTvLDpG!DTW#O(1hzc zYGXoG9R}=>yXEjp6@BP?Pap>3GvG)`4g9EcAy(%6R6)Z;v>O8fj!~@aan<#^P`RQy zIWcMT)3F<6X5yZ*w|iI~n&%mYPHU*%$Mr9%^T0(vgMP)DELV%N(R+*cMfFkB37D}$ zW6zNrZIj&Nk-l+8l&sPZi(t3IGKJlCZb2B8GVKyHK61#K^fpjPx?Y8^k|9uAT5<1n zTI7v&JMzQBuf-g(#2tFCFiN)hNgEU(8}R)+N#V!D2)o(p#SIp_8jV7fy$6&Whl{_< zF$FcRl;*Xm_mL*8LOWemB$uKl{o4kROtl&PNBXfTw@?F3;Y$rQ^KUSbz&_!S=SA21 z2CpAa4^||aGR49Rn~1w&XvlZHoXWV5^WJ{i2~N<%-yL zyo#E*UTSl1|2b*?^&q38f9S309L`lB7q+{vykQedA)OnIZJw-#wEQdDJ;5vgzKE8K zT&pf3hCp4m5Z^bDpZ@C51Hm63C*$4q`PQ|Y&LdoUVUf04rcrhdVep#@Y+wgII6y<; zj_usl)Y^)@-5W*^77(ZX^}A;qskZSz999M-GPhBkk^lg%Ndo}5|49a9n~X3rJv2Ow zL^cm3(@9|z8iNu_ZFfH&s&WJpPf^C3WSJC=?Nf))rOnJ^Q{il9Pojwn75_NB2j#Jyg!g;8?Rtd zT{3#k;5S`_ZJ3uVOFc--Ez8LjD(gnFb2l7@vvHYhutO0LeOvuObB0DTqti9wMf%w? zP9*ZY?T3;h0M2D$p%ReqQU{KY3K%ATcsU5D9wv@iI&c zWOyPG&7XPEV^57tKU%k#q@@iNM=umVc*9D>SAxk#fs7ILn9t4PY5%y!FYh=_=ID8V ziB}%2G?qIgRHi09P(yj&!W=G#<>{3_6Y34ZXd>aeu@m(CF(P+iVYMzj|NgO09?5*w za?HuMs${`4pkGI!MU)_LX^lq!m2xUJel&KSVD6vjVR6lx2$R2X)5Me~+SW03x!m5U z5azn(IE%${o7;;+dfFw=DHU;;j^rc^d`5?T`_>ZMJLwUBs9u0WI3E^lBZ(&WJ5^O{}>t{t>cv)(jpZjHoJ+~;KaH2a-Eu;ZKzNOypcp|tJf&)X#8us{h2;O`E# zo6sFEzt--4_0N;L