From 73017836dc969ceb82d2dd3a5094d13e50dd656f Mon Sep 17 00:00:00 2001 From: ipa-nhg Date: Mon, 7 Nov 2022 15:59:20 +0100 Subject: [PATCH] First version of the DSL grammar with yaml format --- .../.classpath | 9 + .../de.fraunhofer.ipa.ros1.xtext.ide/.project | 34 + .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 10 + .../META-INF/MANIFEST.MF | 17 + .../build.properties | 6 + .../services/org.eclipse.xtext.ISetup | 1 + .../ipa/ros1/ide/AbstractRos1IdeModule.java | 67 + .../antlr/PartialRos1ContentAssistParser.java | 33 + .../ide/contentassist/antlr/Ros1Parser.java | 118 + .../antlr/internal/InternalRos1Parser.g | 2556 ++++++ .../antlr/internal/InternalRos1Parser.java | 7505 +++++++++++++++++ .../antlr/internal/InternalRos1Parser.tokens | 26 + .../antlr/lexer/InternalRos1Lexer.g | 64 + .../antlr/lexer/InternalRos1Lexer.java | 1508 ++++ .../antlr/lexer/InternalRos1Lexer.tokens | 26 + .../ipa/ros1/ide/Ros1IdeModule.java | 11 + .../fraunhofer/ipa/ros1/ide/Ros1IdeSetup.java | 22 + .../contentassist/antlr/Ros1TokenSource.java | 39 + .../.classpath | 9 + .../de.fraunhofer.ipa.ros1.xtext.ui/.project | 34 + .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 10 + .../META-INF/MANIFEST.MF | 25 + .../build.properties | 7 + .../plugin.xml | 434 + .../ipa/ros1/ui/AbstractRos1UiModule.java | 300 + .../ui/Ros1ExecutableExtensionFactory.java | 29 + .../AbstractRos1ProposalProvider.java | 124 + .../Ros1ValidatorConfigurationBlock.java | 35 + .../xtext/ui/internal/XtextActivator.java | 94 + .../fraunhofer/ipa/ros1/ui/Ros1UiModule.java | 16 + .../contentassist/Ros1ProposalProvider.java | 12 + .../Ros1DescriptionLabelProvider.java | 25 + .../ros1/ui/labeling/Ros1LabelProvider.java | 31 + .../ui/outline/Ros1OutlineTreeProvider.java | 15 + .../ui/quickfix/Ros1QuickfixProvider.java | 26 + .../de.fraunhofer.ipa.ros1.xtext/.classpath | 9 + ...Ros1 (ros1) Language Infrastructure.launch | 18 + .../.launch/Launch Runtime Eclipse.launch | 34 + plugins/de.fraunhofer.ipa.ros1.xtext/.project | 34 + .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 10 + .../META-INF/MANIFEST.MF | 27 + .../build.properties | 17 + .../ipa/ros1/AbstractRos1RuntimeModule.java | 208 + .../de/fraunhofer/ipa/ros1/Ros1.xtextbin | Bin 0 -> 3804 bytes .../ros1/Ros1StandaloneSetupGenerated.java | 37 + .../antlr/Ros1AntlrTokenFileProvider.java | 16 + .../ipa/ros1/parser/antlr/Ros1Parser.java | 55 + .../antlr/internal/InternalRos1Parser.g | 859 ++ .../antlr/internal/InternalRos1Parser.java | 2134 +++++ .../antlr/internal/InternalRos1Parser.tokens | 26 + .../parser/antlr/lexer/InternalRos1Lexer.g | 64 + .../parser/antlr/lexer/InternalRos1Lexer.java | 1508 ++++ .../antlr/lexer/InternalRos1Lexer.tokens | 26 + .../scoping/AbstractRos1ScopeProvider.java | 9 + .../serializer/Ros1SemanticSequencer.java | 204 + .../serializer/Ros1SyntacticSequencer.java | 131 + .../ipa/ros1/services/Ros1GrammarAccess.java | 980 +++ .../validation/AbstractRos1Validator.java | 19 + .../Ros1ConfigurableIssueCodesProvider.java | 22 + .../de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 | 61 + .../src/de/fraunhofer/ipa/ros1/Ros1.xtext | 112 + .../ipa/ros1/Ros1RuntimeModule.java | 11 + .../ipa/ros1/Ros1StandaloneSetup.java | 15 + .../ipa/ros1/formatting2/Ros1Formatter.xtend | 32 + .../ipa/ros1/generator/Ros1Generator.xtend | 25 + .../ros1/parser/antlr/Ros1TokenSource.java | 35 + .../ipa/ros1/scoping/Ros1ScopeProvider.java | 15 + .../ipa/ros1/validation/Ros1Validator.java | 25 + 71 files changed, 20062 insertions(+) create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/.classpath create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/.project create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.core.resources.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.jdt.core.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/META-INF/MANIFEST.MF create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/build.properties create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/AbstractRos1IdeModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/PartialRos1ContentAssistParser.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1Parser.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.g create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.tokens create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.g create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.tokens create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeSetup.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1TokenSource.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/.classpath create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/.project create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.core.resources.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.jdt.core.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/META-INF/MANIFEST.MF create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/build.properties create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/plugin.xml create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/AbstractRos1UiModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/Ros1ExecutableExtensionFactory.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/contentassist/AbstractRos1ProposalProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ValidatorConfigurationBlock.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/xtext/ui/internal/XtextActivator.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/Ros1UiModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/contentassist/Ros1ProposalProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1DescriptionLabelProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1LabelProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/outline/Ros1OutlineTreeProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/quickfix/Ros1QuickfixProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.classpath create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Generate Ros1 (ros1) Language Infrastructure.launch create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Launch Runtime Eclipse.launch create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.project create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.core.resources.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.jdt.core.prefs create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/META-INF/MANIFEST.MF create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/build.properties create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/AbstractRos1RuntimeModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1.xtextbin create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1StandaloneSetupGenerated.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1AntlrTokenFileProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/Ros1Parser.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.g create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.g create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.tokens create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/scoping/AbstractRos1ScopeProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SemanticSequencer.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SyntacticSequencer.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/services/Ros1GrammarAccess.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/AbstractRos1Validator.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ConfigurableIssueCodesProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1.xtext create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1RuntimeModule.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1StandaloneSetup.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/formatting2/Ros1Formatter.xtend create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/generator/Ros1Generator.xtend create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/parser/antlr/Ros1TokenSource.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/scoping/Ros1ScopeProvider.java create mode 100644 plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/validation/Ros1Validator.java diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.classpath b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.project b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.project new file mode 100644 index 000000000..2f936053c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros1.xtext.ide + + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.jdt.core.javanature + org.eclipse.pde.PluginNature + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,10 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.compliance=11 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/META-INF/MANIFEST.MF new file mode 100644 index 000000000..9bdebc2ad --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/META-INF/MANIFEST.MF @@ -0,0 +1,17 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros1.xtext.ide +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros1.xtext.ide +Bundle-Vendor: My Company +Bundle-Version: 1.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros1.xtext.ide; singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: de.fraunhofer.ipa.ros1.xtext, + de.fraunhofer.ipa.ros, + org.eclipse.xtext.ide, + org.eclipse.xtext.xbase.ide, + org.antlr.runtime;bundle-version="[3.2.0,3.2.1)" +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Export-Package: de.fraunhofer.ipa.ros1.ide.contentassist.antlr.internal, + de.fraunhofer.ipa.ros1.ide.contentassist.antlr.lexer, + de.fraunhofer.ipa.ros1.ide.contentassist.antlr diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/build.properties b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/build.properties new file mode 100644 index 000000000..5c6bbf99f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/build.properties @@ -0,0 +1,6 @@ +source.. = src/,\ + src-gen/,\ + xtend-gen/ +bin.includes = .,\ + META-INF/ +bin.excludes = **/*.xtend diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup new file mode 100644 index 000000000..df01027f7 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup @@ -0,0 +1 @@ +de.fraunhofer.ipa.ros1.ide.Ros1IdeSetup diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/AbstractRos1IdeModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/AbstractRos1IdeModule.java new file mode 100644 index 000000000..ed5ac9f53 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/AbstractRos1IdeModule.java @@ -0,0 +1,67 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide; + +import com.google.inject.Binder; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.Ros1Parser; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.lexer.InternalRos1Lexer; +import org.eclipse.xtext.ide.DefaultIdeModule; +import org.eclipse.xtext.ide.LexerIdeBindings; +import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider; +import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher; +import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher; +import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; +import org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider; +import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; +import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.ide.refactoring.IRenameStrategy2; +import org.eclipse.xtext.ide.server.rename.IRenameService2; +import org.eclipse.xtext.ide.server.rename.RenameService2; + +/** + * Manual modifications go to {@link Ros1IdeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos1IdeModule extends DefaultIdeModule { + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureContentAssistLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST)) + .to(InternalRos1Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIContentAssistParser() { + return Ros1Parser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIProposalConflictHelper() { + return AntlrProposalConflictHelper.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindCompletionPrefixProvider() { + return IndentationAwareCompletionPrefixProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameService2() { + return RenameService2.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameStrategy2() { + return IRenameStrategy2.DefaultImpl.class; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/PartialRos1ContentAssistParser.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/PartialRos1ContentAssistParser.java new file mode 100644 index 000000000..84e48965a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/PartialRos1ContentAssistParser.java @@ -0,0 +1,33 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr; + +import java.util.Collection; +import java.util.Collections; +import org.eclipse.xtext.AbstractRule; +import org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.util.PolymorphicDispatcher; + +public class PartialRos1ContentAssistParser extends Ros1Parser { + + private AbstractRule rule; + + @Override + public void initializeFor(AbstractRule rule) { + this.rule = rule; + } + + @Override + protected Collection getFollowElements(AbstractInternalContentAssistParser parser) { + if (rule == null || rule.eIsProxy()) + return Collections.emptyList(); + String methodName = "entryRule" + rule.getName(); + PolymorphicDispatcher> dispatcher = + new PolymorphicDispatcher>(methodName, 0, 0, Collections.singletonList(parser)); + dispatcher.invoke(); + return parser.getFollowElements(); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1Parser.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1Parser.java new file mode 100644 index 000000000..3fb1343e1 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1Parser.java @@ -0,0 +1,118 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr; + +import com.google.common.collect.ImmutableMap; +import com.google.inject.Inject; +import com.google.inject.Singleton; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.internal.InternalRos1Parser; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; +import java.util.Map; +import org.antlr.runtime.CharStream; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.AbstractElement; +import org.eclipse.xtext.ide.editor.contentassist.antlr.AbstractContentAssistParser; + +public class Ros1Parser extends AbstractContentAssistParser { + + @Singleton + public static final class NameMappings { + + private final Map mappings; + + @Inject + public NameMappings(Ros1GrammarAccess grammarAccess) { + ImmutableMap.Builder builder = ImmutableMap.builder(); + init(builder, grammarAccess); + this.mappings = builder.build(); + } + + public String getRuleName(AbstractElement element) { + return mappings.get(element); + } + + private static void init(ImmutableMap.Builder builder, Ros1GrammarAccess grammarAccess) { + builder.put(grammarAccess.getDependencyAccess().getAlternatives(), "rule__Dependency__Alternatives"); + builder.put(grammarAccess.getRosNamesAccess().getAlternatives(), "rule__RosNames__Alternatives"); + builder.put(grammarAccess.getEStringAccess().getAlternatives(), "rule__EString__Alternatives"); + builder.put(grammarAccess.getRosParamNamesAccess().getAlternatives(), "rule__RosParamNames__Alternatives"); + builder.put(grammarAccess.getCatkinPackageAccess().getGroup(), "rule__CatkinPackage__Group__0"); + builder.put(grammarAccess.getCatkinPackageAccess().getGroup_4(), "rule__CatkinPackage__Group_4__0"); + builder.put(grammarAccess.getCatkinPackageAccess().getGroup_5(), "rule__CatkinPackage__Group_5__0"); + builder.put(grammarAccess.getCatkinPackageAccess().getGroup_6(), "rule__CatkinPackage__Group_6__0"); + builder.put(grammarAccess.getCatkinPackageAccess().getGroup_6_3(), "rule__CatkinPackage__Group_6_3__0"); + builder.put(grammarAccess.getArtifactAccess().getGroup(), "rule__Artifact__Group__0"); + builder.put(grammarAccess.getNodeAccess().getGroup(), "rule__Node__Group__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_3(), "rule__Node__Group_3__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_4(), "rule__Node__Group_4__0"); + builder.put(grammarAccess.getNodeAccess().getGroup_5(), "rule__Node__Group_5__0"); + builder.put(grammarAccess.getPublisherAccess().getGroup(), "rule__Publisher__Group__0"); + builder.put(grammarAccess.getSubscriberAccess().getGroup(), "rule__Subscriber__Group__0"); + builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0"); + builder.put(grammarAccess.getExternalDependencyAccess().getGroup(), "rule__ExternalDependency__Group__0"); + builder.put(grammarAccess.getCatkinPackageAccess().getNameAssignment_1(), "rule__CatkinPackage__NameAssignment_1"); + builder.put(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1(), "rule__CatkinPackage__FromGitRepoAssignment_4_1"); + builder.put(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2(), "rule__CatkinPackage__ArtifactAssignment_5_2"); + builder.put(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2(), "rule__CatkinPackage__DependencyAssignment_6_2"); + builder.put(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1(), "rule__CatkinPackage__DependencyAssignment_6_3_1"); + builder.put(grammarAccess.getArtifactAccess().getNameAssignment_1(), "rule__Artifact__NameAssignment_1"); + builder.put(grammarAccess.getArtifactAccess().getNodeAssignment_4(), "rule__Artifact__NodeAssignment_4"); + builder.put(grammarAccess.getNodeAccess().getNameAssignment_1(), "rule__Node__NameAssignment_1"); + builder.put(grammarAccess.getNodeAccess().getPublisherAssignment_3_2(), "rule__Node__PublisherAssignment_3_2"); + builder.put(grammarAccess.getNodeAccess().getSubscriberAssignment_4_2(), "rule__Node__SubscriberAssignment_4_2"); + builder.put(grammarAccess.getNodeAccess().getParameterAssignment_5_2(), "rule__Node__ParameterAssignment_5_2"); + builder.put(grammarAccess.getPublisherAccess().getNameAssignment_1(), "rule__Publisher__NameAssignment_1"); + builder.put(grammarAccess.getPublisherAccess().getMessageAssignment_5(), "rule__Publisher__MessageAssignment_5"); + builder.put(grammarAccess.getSubscriberAccess().getNameAssignment_1(), "rule__Subscriber__NameAssignment_1"); + builder.put(grammarAccess.getSubscriberAccess().getMessageAssignment_5(), "rule__Subscriber__MessageAssignment_5"); + builder.put(grammarAccess.getParameterAccess().getNameAssignment_1(), "rule__Parameter__NameAssignment_1"); + builder.put(grammarAccess.getPackageDependencyAccess().getPackageAssignment(), "rule__PackageDependency__PackageAssignment"); + builder.put(grammarAccess.getExternalDependencyAccess().getNameAssignment_2(), "rule__ExternalDependency__NameAssignment_2"); + } + } + + @Inject + private NameMappings nameMappings; + + @Inject + private Ros1GrammarAccess grammarAccess; + + @Override + protected InternalRos1Parser createParser() { + InternalRos1Parser result = new InternalRos1Parser(null); + result.setGrammarAccess(grammarAccess); + return result; + } + + @Override + protected TokenSource createLexer(CharStream stream) { + return new Ros1TokenSource(super.createLexer(stream)); + } + + @Override + protected String getRuleName(AbstractElement element) { + return nameMappings.getRuleName(element); + } + + @Override + protected String[] getInitialHiddenTokens() { + return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" }; + } + + public Ros1GrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(Ros1GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + public NameMappings getNameMappings() { + return nameMappings; + } + + public void setNameMappings(NameMappings nameMappings) { + this.nameMappings = nameMappings; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.g b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.g new file mode 100644 index 000000000..722f95346 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.g @@ -0,0 +1,2556 @@ +/* + * generated by Xtext 2.25.0 + */ +parser grammar InternalRos1Parser; + +options { + tokenVocab=InternalRos1Lexer; + superClass=AbstractInternalContentAssistParser; +} + +@header { +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr.internal; +import java.util.Map; +import java.util.HashMap; + +import java.io.InputStream; +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.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; + +} +@members { + private Ros1GrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type", "'type:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + } + + public void setGrammarAccess(Ros1GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + String result = tokenNameToValue.get(tokenName); + if (result == null) + result = tokenName; + return result; + } +} + +// Entry rule entryRuleCatkinPackage +entryRuleCatkinPackage +: +{ before(grammarAccess.getCatkinPackageRule()); } + ruleCatkinPackage +{ after(grammarAccess.getCatkinPackageRule()); } + EOF +; + +// Rule CatkinPackage +ruleCatkinPackage + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getCatkinPackageAccess().getGroup()); } + (rule__CatkinPackage__Group__0) + { after(grammarAccess.getCatkinPackageAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArtifact +entryRuleArtifact +: +{ before(grammarAccess.getArtifactRule()); } + ruleArtifact +{ after(grammarAccess.getArtifactRule()); } + EOF +; + +// Rule Artifact +ruleArtifact + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArtifactAccess().getGroup()); } + (rule__Artifact__Group__0) + { after(grammarAccess.getArtifactAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleNode +entryRuleNode +: +{ before(grammarAccess.getNodeRule()); } + ruleNode +{ after(grammarAccess.getNodeRule()); } + EOF +; + +// Rule Node +ruleNode + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNodeAccess().getGroup()); } + (rule__Node__Group__0) + { after(grammarAccess.getNodeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulePublisher +entryRulePublisher +: +{ before(grammarAccess.getPublisherRule()); } + rulePublisher +{ after(grammarAccess.getPublisherRule()); } + EOF +; + +// Rule Publisher +rulePublisher + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPublisherAccess().getGroup()); } + (rule__Publisher__Group__0) + { after(grammarAccess.getPublisherAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleSubscriber +entryRuleSubscriber +: +{ before(grammarAccess.getSubscriberRule()); } + ruleSubscriber +{ after(grammarAccess.getSubscriberRule()); } + EOF +; + +// Rule Subscriber +ruleSubscriber + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getSubscriberAccess().getGroup()); } + (rule__Subscriber__Group__0) + { after(grammarAccess.getSubscriberAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameter +entryRuleParameter +: +{ before(grammarAccess.getParameterRule()); } + ruleParameter +{ after(grammarAccess.getParameterRule()); } + EOF +; + +// Rule Parameter +ruleParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterAccess().getGroup()); } + (rule__Parameter__Group__0) + { after(grammarAccess.getParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDependency +entryRuleDependency +: +{ before(grammarAccess.getDependencyRule()); } + ruleDependency +{ after(grammarAccess.getDependencyRule()); } + EOF +; + +// Rule Dependency +ruleDependency + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDependencyAccess().getAlternatives()); } + (rule__Dependency__Alternatives) + { after(grammarAccess.getDependencyAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulePackageDependency +entryRulePackageDependency +: +{ before(grammarAccess.getPackageDependencyRule()); } + rulePackageDependency +{ after(grammarAccess.getPackageDependencyRule()); } + EOF +; + +// Rule PackageDependency +rulePackageDependency + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); } + (rule__PackageDependency__PackageAssignment) + { after(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleExternalDependency +entryRuleExternalDependency +: +{ before(grammarAccess.getExternalDependencyRule()); } + ruleExternalDependency +{ after(grammarAccess.getExternalDependencyRule()); } + EOF +; + +// Rule ExternalDependency +ruleExternalDependency + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getExternalDependencyAccess().getGroup()); } + (rule__ExternalDependency__Group__0) + { after(grammarAccess.getExternalDependencyAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleRosNames +entryRuleRosNames +: +{ before(grammarAccess.getRosNamesRule()); } + ruleRosNames +{ after(grammarAccess.getRosNamesRule()); } + EOF +; + +// Rule RosNames +ruleRosNames + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getRosNamesAccess().getAlternatives()); } + (rule__RosNames__Alternatives) + { after(grammarAccess.getRosNamesAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleEString +entryRuleEString +: +{ before(grammarAccess.getEStringRule()); } + ruleEString +{ after(grammarAccess.getEStringRule()); } + EOF +; + +// Rule EString +ruleEString + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getEStringAccess().getAlternatives()); } + (rule__EString__Alternatives) + { after(grammarAccess.getEStringAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Dependency__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); } + rulePackageDependency + { after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); } + ruleExternalDependency + { after(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RosNames__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); } + RULE_ROS_CONVENTION_A + { after(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); } + RULE_ID + { after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } + Node + { after(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EString__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); } + RULE_STRING + { after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); } + RULE_ID + { after(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__0__Impl + rule__CatkinPackage__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); } + () + { after(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__1__Impl + rule__CatkinPackage__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getNameAssignment_1()); } + (rule__CatkinPackage__NameAssignment_1) + { after(grammarAccess.getCatkinPackageAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__2__Impl + rule__CatkinPackage__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__3__Impl + rule__CatkinPackage__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__4__Impl + rule__CatkinPackage__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getGroup_4()); } + (rule__CatkinPackage__Group_4__0)? + { after(grammarAccess.getCatkinPackageAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__5__Impl + rule__CatkinPackage__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getGroup_5()); } + (rule__CatkinPackage__Group_5__0)? + { after(grammarAccess.getCatkinPackageAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__6__Impl + rule__CatkinPackage__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getGroup_6()); } + (rule__CatkinPackage__Group_6__0)? + { after(grammarAccess.getCatkinPackageAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); } + RULE_END + { after(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CatkinPackage__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_4__0__Impl + rule__CatkinPackage__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); } + FromGitRepo + { after(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); } + (rule__CatkinPackage__FromGitRepoAssignment_4_1) + { after(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CatkinPackage__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_5__0__Impl + rule__CatkinPackage__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); } + Artifacts + { after(grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_5__1__Impl + rule__CatkinPackage__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_5__2__Impl + rule__CatkinPackage__Group_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2()); } + (rule__CatkinPackage__ArtifactAssignment_5_2)* + { after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CatkinPackage__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6__0__Impl + rule__CatkinPackage__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); } + Dependencies + { after(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6__1__Impl + rule__CatkinPackage__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); } + LeftSquareBracket + { after(grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6__2__Impl + rule__CatkinPackage__Group_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2()); } + (rule__CatkinPackage__DependencyAssignment_6_2) + { after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6__3__Impl + rule__CatkinPackage__Group_6__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); } + (rule__CatkinPackage__Group_6_3__0)* + { after(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); } + RightSquareBracket + { after(grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CatkinPackage__Group_6_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6_3__0__Impl + rule__CatkinPackage__Group_6_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); } + Comma + { after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CatkinPackage__Group_6_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__Group_6_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1()); } + (rule__CatkinPackage__DependencyAssignment_6_3_1) + { after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Artifact__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__0__Impl + rule__Artifact__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getArtifactAction_0()); } + () + { after(grammarAccess.getArtifactAccess().getArtifactAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__1__Impl + rule__Artifact__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getNameAssignment_1()); } + (rule__Artifact__NameAssignment_1) + { after(grammarAccess.getArtifactAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__2__Impl + rule__Artifact__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getArtifactAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__3__Impl + rule__Artifact__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__4__Impl + rule__Artifact__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); } + (rule__Artifact__NodeAssignment_4)? + { after(grammarAccess.getArtifactAccess().getNodeAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Artifact__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } + RULE_END + { after(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__0__Impl + rule__Node__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getNodeKeyword_0()); } + Node_1 + { after(grammarAccess.getNodeAccess().getNodeKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__1__Impl + rule__Node__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getNameAssignment_1()); } + (rule__Node__NameAssignment_1) + { after(grammarAccess.getNodeAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__2__Impl + rule__Node__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__3__Impl + rule__Node__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getGroup_3()); } + (rule__Node__Group_3__0)? + { after(grammarAccess.getNodeAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__4__Impl + rule__Node__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getGroup_4()); } + (rule__Node__Group_4__0)? + { after(grammarAccess.getNodeAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__5__Impl + rule__Node__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getGroup_5()); } + (rule__Node__Group_5__0)? + { after(grammarAccess.getNodeAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3__0__Impl + rule__Node__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0()); } + Publishers + { after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3__1__Impl + rule__Node__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3__2__Impl + rule__Node__Group_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getPublisherAssignment_3_2()); } + (rule__Node__PublisherAssignment_3_2)* + { after(grammarAccess.getNodeAccess().getPublisherAssignment_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_4__0__Impl + rule__Node__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()); } + Subscribers + { after(grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_4__1__Impl + rule__Node__Group_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_4__2__Impl + rule__Node__Group_4__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getSubscriberAssignment_4_2()); } + (rule__Node__SubscriberAssignment_4_2)* + { after(grammarAccess.getNodeAccess().getSubscriberAssignment_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_4__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_4__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Node__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_5__0__Impl + rule__Node__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParametersKeyword_5_0()); } + Parameters + { after(grammarAccess.getNodeAccess().getParametersKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_5__1__Impl + rule__Node__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()); } + RULE_BEGIN + { after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_5__2__Impl + rule__Node__Group_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getParameterAssignment_5_2()); } + (rule__Node__ParameterAssignment_5_2)* + { after(grammarAccess.getNodeAccess().getParameterAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Node__Group_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__Group_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3()); } + RULE_END + { after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Publisher__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__0__Impl + rule__Publisher__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getPublisherAction_0()); } + () + { after(grammarAccess.getPublisherAccess().getPublisherAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__1__Impl + rule__Publisher__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getNameAssignment_1()); } + (rule__Publisher__NameAssignment_1) + { after(grammarAccess.getPublisherAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__2__Impl + rule__Publisher__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getPublisherAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__3__Impl + rule__Publisher__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__4__Impl + rule__Publisher__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); } + Type + { after(grammarAccess.getPublisherAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__5__Impl + rule__Publisher__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } + (rule__Publisher__MessageAssignment_5) + { after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Publisher__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Subscriber__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__0__Impl + rule__Subscriber__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); } + () + { after(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__1__Impl + rule__Subscriber__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); } + (rule__Subscriber__NameAssignment_1) + { after(grammarAccess.getSubscriberAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__2__Impl + rule__Subscriber__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getSubscriberAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__3__Impl + rule__Subscriber__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__4__Impl + rule__Subscriber__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } + Type + { after(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__5__Impl + rule__Subscriber__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } + (rule__Subscriber__MessageAssignment_5) + { after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Subscriber__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_6()); } + RULE_END + { after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Parameter__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__0__Impl + rule__Parameter__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getParameterAction_0()); } + () + { after(grammarAccess.getParameterAccess().getParameterAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__1__Impl + rule__Parameter__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNameAssignment_1()); } + (rule__Parameter__NameAssignment_1) + { after(grammarAccess.getParameterAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__2__Impl + rule__Parameter__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getColonKeyword_2()); } + Colon + { after(grammarAccess.getParameterAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__3__Impl + rule__Parameter__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } + RULE_BEGIN + { after(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__4__Impl + rule__Parameter__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_4()); } + RULE_END + { after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_5()); } + RightCurlyBracket + { after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ExternalDependency__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExternalDependency__Group__0__Impl + rule__ExternalDependency__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } + () + { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExternalDependency__Group__1__Impl + rule__ExternalDependency__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } + ExternalDependency + { after(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExternalDependency__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } + (rule__ExternalDependency__NameAssignment_2) + { after(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CatkinPackage__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__FromGitRepoAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ruleEString + { after(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__ArtifactAssignment_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); } + ruleArtifact + { after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__DependencyAssignment_6_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ruleDependency + { after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CatkinPackage__DependencyAssignment_6_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ruleDependency + { after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Artifact__NodeAssignment_4 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } + ruleNode + { after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } + ruleRosNames + { after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__PublisherAssignment_3_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_2_0()); } + rulePublisher + { after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__SubscriberAssignment_4_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_4_2_0()); } + ruleSubscriber + { after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_4_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Node__ParameterAssignment_5_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_5_2_0()); } + ruleParameter + { after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_5_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Publisher__MessageAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Subscriber__MessageAssignment_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); } + ( + { before(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } + ruleEString + { after(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); } + ) + { after(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); } + ruleEString + { after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PackageDependency__PackageAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); } + ( + { before(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1()); } + ruleEString + { after(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1()); } + ) + { after(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExternalDependency__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); } + ruleEString + { after(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.java new file mode 100644 index 000000000..9890eef80 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.java @@ -0,0 +1,7505 @@ +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr.internal; +import java.util.Map; +import java.util.HashMap; + +import java.io.InputStream; +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.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalRos1Parser extends AbstractInternalContentAssistParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "ExternalDependency", "Dependencies", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "Node_1", "Type", "Node", "Comma", "Colon", "LeftSquareBracket", "RightSquareBracket", "RightCurlyBracket", "RULE_BEGIN", "RULE_END", "RULE_SL_COMMENT", "RULE_ID", "RULE_ROS_CONVENTION_A", "RULE_STRING", "RULE_ROS_CONVENTION_PARAM", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int RULE_END=20; + public static final int RULE_BEGIN=19; + public static final int Node=13; + public static final int RULE_STRING=24; + public static final int RULE_SL_COMMENT=21; + public static final int Comma=14; + public static final int RULE_ROS_CONVENTION_A=23; + public static final int Publishers=9; + public static final int RULE_ROS_CONVENTION_PARAM=25; + public static final int Dependencies=5; + public static final int Colon=15; + public static final int RightCurlyBracket=18; + public static final int EOF=-1; + public static final int RightSquareBracket=17; + public static final int FromGitRepo=6; + public static final int ExternalDependency=4; + public static final int Parameters=8; + public static final int RULE_ID=22; + public static final int RULE_WS=28; + public static final int RULE_ANY_OTHER=29; + public static final int Artifacts=10; + public static final int Node_1=11; + public static final int Type=12; + public static final int RULE_INT=26; + public static final int RULE_ML_COMMENT=27; + public static final int LeftSquareBracket=16; + public static final int Subscribers=7; + + // delegates + // delegators + + + public InternalRos1Parser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos1Parser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalRos1Parser.tokenNames; } + public String getGrammarFileName() { return "InternalRos1Parser.g"; } + + + private Ros1GrammarAccess grammarAccess; + private final Map tokenNameToValue = new HashMap(); + + { + tokenNameToValue.put("Comma", "','"); + tokenNameToValue.put("Colon", "':'"); + tokenNameToValue.put("LeftSquareBracket", "'['"); + tokenNameToValue.put("RightSquareBracket", "']'"); + tokenNameToValue.put("RightCurlyBracket", "'}'"); + tokenNameToValue.put("Node", "'node'"); + tokenNameToValue.put("Node_1", "'node:'"); + tokenNameToValue.put("Type", "'type:'"); + tokenNameToValue.put("Artifacts", "'artifacts:'"); + tokenNameToValue.put("Parameters", "'parameters:'"); + tokenNameToValue.put("Publishers", "'publishers:'"); + tokenNameToValue.put("FromGitRepo", "'fromGitRepo:'"); + tokenNameToValue.put("Subscribers", "'subscribers:'"); + tokenNameToValue.put("Dependencies", "'dependencies:'"); + tokenNameToValue.put("ExternalDependency", "'ExternalDependency'"); + } + + public void setGrammarAccess(Ros1GrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + String result = tokenNameToValue.get(tokenName); + if (result == null) + result = tokenName; + return result; + } + + + + // $ANTLR start "entryRuleCatkinPackage" + // InternalRos1Parser.g:70:1: entryRuleCatkinPackage : ruleCatkinPackage EOF ; + public final void entryRuleCatkinPackage() throws RecognitionException { + try { + // InternalRos1Parser.g:71:1: ( ruleCatkinPackage EOF ) + // InternalRos1Parser.g:72:1: ruleCatkinPackage EOF + { + before(grammarAccess.getCatkinPackageRule()); + pushFollow(FOLLOW_1); + ruleCatkinPackage(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleCatkinPackage" + + + // $ANTLR start "ruleCatkinPackage" + // InternalRos1Parser.g:79:1: ruleCatkinPackage : ( ( rule__CatkinPackage__Group__0 ) ) ; + public final void ruleCatkinPackage() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:83:2: ( ( ( rule__CatkinPackage__Group__0 ) ) ) + // InternalRos1Parser.g:84:2: ( ( rule__CatkinPackage__Group__0 ) ) + { + // InternalRos1Parser.g:84:2: ( ( rule__CatkinPackage__Group__0 ) ) + // InternalRos1Parser.g:85:3: ( rule__CatkinPackage__Group__0 ) + { + before(grammarAccess.getCatkinPackageAccess().getGroup()); + // InternalRos1Parser.g:86:3: ( rule__CatkinPackage__Group__0 ) + // InternalRos1Parser.g:86:4: rule__CatkinPackage__Group__0 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getCatkinPackageAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleCatkinPackage" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos1Parser.g:95:1: entryRuleArtifact : ruleArtifact EOF ; + public final void entryRuleArtifact() throws RecognitionException { + try { + // InternalRos1Parser.g:96:1: ( ruleArtifact EOF ) + // InternalRos1Parser.g:97:1: ruleArtifact EOF + { + before(grammarAccess.getArtifactRule()); + pushFollow(FOLLOW_1); + ruleArtifact(); + + state._fsp--; + + after(grammarAccess.getArtifactRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleArtifact" + + + // $ANTLR start "ruleArtifact" + // InternalRos1Parser.g:104:1: ruleArtifact : ( ( rule__Artifact__Group__0 ) ) ; + public final void ruleArtifact() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:108:2: ( ( ( rule__Artifact__Group__0 ) ) ) + // InternalRos1Parser.g:109:2: ( ( rule__Artifact__Group__0 ) ) + { + // InternalRos1Parser.g:109:2: ( ( rule__Artifact__Group__0 ) ) + // InternalRos1Parser.g:110:3: ( rule__Artifact__Group__0 ) + { + before(grammarAccess.getArtifactAccess().getGroup()); + // InternalRos1Parser.g:111:3: ( rule__Artifact__Group__0 ) + // InternalRos1Parser.g:111:4: rule__Artifact__Group__0 + { + pushFollow(FOLLOW_2); + rule__Artifact__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getArtifactAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleArtifact" + + + // $ANTLR start "entryRuleNode" + // InternalRos1Parser.g:120:1: entryRuleNode : ruleNode EOF ; + public final void entryRuleNode() throws RecognitionException { + try { + // InternalRos1Parser.g:121:1: ( ruleNode EOF ) + // InternalRos1Parser.g:122:1: ruleNode EOF + { + before(grammarAccess.getNodeRule()); + pushFollow(FOLLOW_1); + ruleNode(); + + state._fsp--; + + after(grammarAccess.getNodeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleNode" + + + // $ANTLR start "ruleNode" + // InternalRos1Parser.g:129:1: ruleNode : ( ( rule__Node__Group__0 ) ) ; + public final void ruleNode() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:133:2: ( ( ( rule__Node__Group__0 ) ) ) + // InternalRos1Parser.g:134:2: ( ( rule__Node__Group__0 ) ) + { + // InternalRos1Parser.g:134:2: ( ( rule__Node__Group__0 ) ) + // InternalRos1Parser.g:135:3: ( rule__Node__Group__0 ) + { + before(grammarAccess.getNodeAccess().getGroup()); + // InternalRos1Parser.g:136:3: ( rule__Node__Group__0 ) + // InternalRos1Parser.g:136:4: rule__Node__Group__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleNode" + + + // $ANTLR start "entryRulePublisher" + // InternalRos1Parser.g:145:1: entryRulePublisher : rulePublisher EOF ; + public final void entryRulePublisher() throws RecognitionException { + try { + // InternalRos1Parser.g:146:1: ( rulePublisher EOF ) + // InternalRos1Parser.g:147:1: rulePublisher EOF + { + before(grammarAccess.getPublisherRule()); + pushFollow(FOLLOW_1); + rulePublisher(); + + state._fsp--; + + after(grammarAccess.getPublisherRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePublisher" + + + // $ANTLR start "rulePublisher" + // InternalRos1Parser.g:154:1: rulePublisher : ( ( rule__Publisher__Group__0 ) ) ; + public final void rulePublisher() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:158:2: ( ( ( rule__Publisher__Group__0 ) ) ) + // InternalRos1Parser.g:159:2: ( ( rule__Publisher__Group__0 ) ) + { + // InternalRos1Parser.g:159:2: ( ( rule__Publisher__Group__0 ) ) + // InternalRos1Parser.g:160:3: ( rule__Publisher__Group__0 ) + { + before(grammarAccess.getPublisherAccess().getGroup()); + // InternalRos1Parser.g:161:3: ( rule__Publisher__Group__0 ) + // InternalRos1Parser.g:161:4: rule__Publisher__Group__0 + { + pushFollow(FOLLOW_2); + rule__Publisher__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePublisher" + + + // $ANTLR start "entryRuleSubscriber" + // InternalRos1Parser.g:170:1: entryRuleSubscriber : ruleSubscriber EOF ; + public final void entryRuleSubscriber() throws RecognitionException { + try { + // InternalRos1Parser.g:171:1: ( ruleSubscriber EOF ) + // InternalRos1Parser.g:172:1: ruleSubscriber EOF + { + before(grammarAccess.getSubscriberRule()); + pushFollow(FOLLOW_1); + ruleSubscriber(); + + state._fsp--; + + after(grammarAccess.getSubscriberRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleSubscriber" + + + // $ANTLR start "ruleSubscriber" + // InternalRos1Parser.g:179:1: ruleSubscriber : ( ( rule__Subscriber__Group__0 ) ) ; + public final void ruleSubscriber() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:183:2: ( ( ( rule__Subscriber__Group__0 ) ) ) + // InternalRos1Parser.g:184:2: ( ( rule__Subscriber__Group__0 ) ) + { + // InternalRos1Parser.g:184:2: ( ( rule__Subscriber__Group__0 ) ) + // InternalRos1Parser.g:185:3: ( rule__Subscriber__Group__0 ) + { + before(grammarAccess.getSubscriberAccess().getGroup()); + // InternalRos1Parser.g:186:3: ( rule__Subscriber__Group__0 ) + // InternalRos1Parser.g:186:4: rule__Subscriber__Group__0 + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleSubscriber" + + + // $ANTLR start "entryRuleParameter" + // InternalRos1Parser.g:195:1: entryRuleParameter : ruleParameter EOF ; + public final void entryRuleParameter() throws RecognitionException { + try { + // InternalRos1Parser.g:196:1: ( ruleParameter EOF ) + // InternalRos1Parser.g:197:1: ruleParameter EOF + { + before(grammarAccess.getParameterRule()); + pushFollow(FOLLOW_1); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getParameterRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalRos1Parser.g:204:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; + public final void ruleParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:208:2: ( ( ( rule__Parameter__Group__0 ) ) ) + // InternalRos1Parser.g:209:2: ( ( rule__Parameter__Group__0 ) ) + { + // InternalRos1Parser.g:209:2: ( ( rule__Parameter__Group__0 ) ) + // InternalRos1Parser.g:210:3: ( rule__Parameter__Group__0 ) + { + before(grammarAccess.getParameterAccess().getGroup()); + // InternalRos1Parser.g:211:3: ( rule__Parameter__Group__0 ) + // InternalRos1Parser.g:211:4: rule__Parameter__Group__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleDependency" + // InternalRos1Parser.g:220:1: entryRuleDependency : ruleDependency EOF ; + public final void entryRuleDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:221:1: ( ruleDependency EOF ) + // InternalRos1Parser.g:222:1: ruleDependency EOF + { + before(grammarAccess.getDependencyRule()); + pushFollow(FOLLOW_1); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDependency" + + + // $ANTLR start "ruleDependency" + // InternalRos1Parser.g:229:1: ruleDependency : ( ( rule__Dependency__Alternatives ) ) ; + public final void ruleDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:233:2: ( ( ( rule__Dependency__Alternatives ) ) ) + // InternalRos1Parser.g:234:2: ( ( rule__Dependency__Alternatives ) ) + { + // InternalRos1Parser.g:234:2: ( ( rule__Dependency__Alternatives ) ) + // InternalRos1Parser.g:235:3: ( rule__Dependency__Alternatives ) + { + before(grammarAccess.getDependencyAccess().getAlternatives()); + // InternalRos1Parser.g:236:3: ( rule__Dependency__Alternatives ) + // InternalRos1Parser.g:236:4: rule__Dependency__Alternatives + { + pushFollow(FOLLOW_2); + rule__Dependency__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getDependencyAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDependency" + + + // $ANTLR start "entryRulePackageDependency" + // InternalRos1Parser.g:245:1: entryRulePackageDependency : rulePackageDependency EOF ; + public final void entryRulePackageDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:246:1: ( rulePackageDependency EOF ) + // InternalRos1Parser.g:247:1: rulePackageDependency EOF + { + before(grammarAccess.getPackageDependencyRule()); + pushFollow(FOLLOW_1); + rulePackageDependency(); + + state._fsp--; + + after(grammarAccess.getPackageDependencyRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePackageDependency" + + + // $ANTLR start "rulePackageDependency" + // InternalRos1Parser.g:254:1: rulePackageDependency : ( ( rule__PackageDependency__PackageAssignment ) ) ; + public final void rulePackageDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:258:2: ( ( ( rule__PackageDependency__PackageAssignment ) ) ) + // InternalRos1Parser.g:259:2: ( ( rule__PackageDependency__PackageAssignment ) ) + { + // InternalRos1Parser.g:259:2: ( ( rule__PackageDependency__PackageAssignment ) ) + // InternalRos1Parser.g:260:3: ( rule__PackageDependency__PackageAssignment ) + { + before(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + // InternalRos1Parser.g:261:3: ( rule__PackageDependency__PackageAssignment ) + // InternalRos1Parser.g:261:4: rule__PackageDependency__PackageAssignment + { + pushFollow(FOLLOW_2); + rule__PackageDependency__PackageAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getPackageDependencyAccess().getPackageAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePackageDependency" + + + // $ANTLR start "entryRuleExternalDependency" + // InternalRos1Parser.g:270:1: entryRuleExternalDependency : ruleExternalDependency EOF ; + public final void entryRuleExternalDependency() throws RecognitionException { + try { + // InternalRos1Parser.g:271:1: ( ruleExternalDependency EOF ) + // InternalRos1Parser.g:272:1: ruleExternalDependency EOF + { + before(grammarAccess.getExternalDependencyRule()); + pushFollow(FOLLOW_1); + ruleExternalDependency(); + + state._fsp--; + + after(grammarAccess.getExternalDependencyRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleExternalDependency" + + + // $ANTLR start "ruleExternalDependency" + // InternalRos1Parser.g:279:1: ruleExternalDependency : ( ( rule__ExternalDependency__Group__0 ) ) ; + public final void ruleExternalDependency() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:283:2: ( ( ( rule__ExternalDependency__Group__0 ) ) ) + // InternalRos1Parser.g:284:2: ( ( rule__ExternalDependency__Group__0 ) ) + { + // InternalRos1Parser.g:284:2: ( ( rule__ExternalDependency__Group__0 ) ) + // InternalRos1Parser.g:285:3: ( rule__ExternalDependency__Group__0 ) + { + before(grammarAccess.getExternalDependencyAccess().getGroup()); + // InternalRos1Parser.g:286:3: ( rule__ExternalDependency__Group__0 ) + // InternalRos1Parser.g:286:4: rule__ExternalDependency__Group__0 + { + pushFollow(FOLLOW_2); + rule__ExternalDependency__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getExternalDependencyAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleExternalDependency" + + + // $ANTLR start "entryRuleRosNames" + // InternalRos1Parser.g:295:1: entryRuleRosNames : ruleRosNames EOF ; + public final void entryRuleRosNames() throws RecognitionException { + try { + // InternalRos1Parser.g:296:1: ( ruleRosNames EOF ) + // InternalRos1Parser.g:297:1: ruleRosNames EOF + { + before(grammarAccess.getRosNamesRule()); + pushFollow(FOLLOW_1); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getRosNamesRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleRosNames" + + + // $ANTLR start "ruleRosNames" + // InternalRos1Parser.g:304:1: ruleRosNames : ( ( rule__RosNames__Alternatives ) ) ; + public final void ruleRosNames() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:308:2: ( ( ( rule__RosNames__Alternatives ) ) ) + // InternalRos1Parser.g:309:2: ( ( rule__RosNames__Alternatives ) ) + { + // InternalRos1Parser.g:309:2: ( ( rule__RosNames__Alternatives ) ) + // InternalRos1Parser.g:310:3: ( rule__RosNames__Alternatives ) + { + before(grammarAccess.getRosNamesAccess().getAlternatives()); + // InternalRos1Parser.g:311:3: ( rule__RosNames__Alternatives ) + // InternalRos1Parser.g:311:4: rule__RosNames__Alternatives + { + pushFollow(FOLLOW_2); + rule__RosNames__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getRosNamesAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleRosNames" + + + // $ANTLR start "entryRuleEString" + // InternalRos1Parser.g:320:1: entryRuleEString : ruleEString EOF ; + public final void entryRuleEString() throws RecognitionException { + try { + // InternalRos1Parser.g:321:1: ( ruleEString EOF ) + // InternalRos1Parser.g:322:1: ruleEString EOF + { + before(grammarAccess.getEStringRule()); + pushFollow(FOLLOW_1); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getEStringRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleEString" + + + // $ANTLR start "ruleEString" + // InternalRos1Parser.g:329:1: ruleEString : ( ( rule__EString__Alternatives ) ) ; + public final void ruleEString() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:333:2: ( ( ( rule__EString__Alternatives ) ) ) + // InternalRos1Parser.g:334:2: ( ( rule__EString__Alternatives ) ) + { + // InternalRos1Parser.g:334:2: ( ( rule__EString__Alternatives ) ) + // InternalRos1Parser.g:335:3: ( rule__EString__Alternatives ) + { + before(grammarAccess.getEStringAccess().getAlternatives()); + // InternalRos1Parser.g:336:3: ( rule__EString__Alternatives ) + // InternalRos1Parser.g:336:4: rule__EString__Alternatives + { + pushFollow(FOLLOW_2); + rule__EString__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getEStringAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleEString" + + + // $ANTLR start "rule__Dependency__Alternatives" + // InternalRos1Parser.g:344:1: rule__Dependency__Alternatives : ( ( rulePackageDependency ) | ( ruleExternalDependency ) ); + public final void rule__Dependency__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:348:1: ( ( rulePackageDependency ) | ( ruleExternalDependency ) ) + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==RULE_ID||LA1_0==RULE_STRING) ) { + alt1=1; + } + else if ( (LA1_0==ExternalDependency) ) { + alt1=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 1, 0, input); + + throw nvae; + } + switch (alt1) { + case 1 : + // InternalRos1Parser.g:349:2: ( rulePackageDependency ) + { + // InternalRos1Parser.g:349:2: ( rulePackageDependency ) + // InternalRos1Parser.g:350:3: rulePackageDependency + { + before(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + pushFollow(FOLLOW_2); + rulePackageDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:355:2: ( ruleExternalDependency ) + { + // InternalRos1Parser.g:355:2: ( ruleExternalDependency ) + // InternalRos1Parser.g:356:3: ruleExternalDependency + { + before(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleExternalDependency(); + + state._fsp--; + + after(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Dependency__Alternatives" + + + // $ANTLR start "rule__RosNames__Alternatives" + // InternalRos1Parser.g:365:1: rule__RosNames__Alternatives : ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ); + public final void rule__RosNames__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:369:1: ( ( RULE_ROS_CONVENTION_A ) | ( RULE_ID ) | ( Node ) ) + int alt2=3; + switch ( input.LA(1) ) { + case RULE_ROS_CONVENTION_A: + { + alt2=1; + } + break; + case RULE_ID: + { + alt2=2; + } + break; + case Node: + { + alt2=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + + switch (alt2) { + case 1 : + // InternalRos1Parser.g:370:2: ( RULE_ROS_CONVENTION_A ) + { + // InternalRos1Parser.g:370:2: ( RULE_ROS_CONVENTION_A ) + // InternalRos1Parser.g:371:3: RULE_ROS_CONVENTION_A + { + before(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + match(input,RULE_ROS_CONVENTION_A,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:376:2: ( RULE_ID ) + { + // InternalRos1Parser.g:376:2: ( RULE_ID ) + // InternalRos1Parser.g:377:3: RULE_ID + { + before(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalRos1Parser.g:382:2: ( Node ) + { + // InternalRos1Parser.g:382:2: ( Node ) + // InternalRos1Parser.g:383:3: Node + { + before(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + match(input,Node,FOLLOW_2); + after(grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RosNames__Alternatives" + + + // $ANTLR start "rule__EString__Alternatives" + // InternalRos1Parser.g:392:1: rule__EString__Alternatives : ( ( RULE_STRING ) | ( RULE_ID ) ); + public final void rule__EString__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:396:1: ( ( RULE_STRING ) | ( RULE_ID ) ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==RULE_STRING) ) { + alt3=1; + } + else if ( (LA3_0==RULE_ID) ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalRos1Parser.g:397:2: ( RULE_STRING ) + { + // InternalRos1Parser.g:397:2: ( RULE_STRING ) + // InternalRos1Parser.g:398:3: RULE_STRING + { + before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + match(input,RULE_STRING,FOLLOW_2); + after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalRos1Parser.g:403:2: ( RULE_ID ) + { + // InternalRos1Parser.g:403:2: ( RULE_ID ) + // InternalRos1Parser.g:404:3: RULE_ID + { + before(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EString__Alternatives" + + + // $ANTLR start "rule__CatkinPackage__Group__0" + // InternalRos1Parser.g:413:1: rule__CatkinPackage__Group__0 : rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 ; + public final void rule__CatkinPackage__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:417:1: ( rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 ) + // InternalRos1Parser.g:418:2: rule__CatkinPackage__Group__0__Impl rule__CatkinPackage__Group__1 + { + pushFollow(FOLLOW_3); + rule__CatkinPackage__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__0" + + + // $ANTLR start "rule__CatkinPackage__Group__0__Impl" + // InternalRos1Parser.g:425:1: rule__CatkinPackage__Group__0__Impl : ( () ) ; + public final void rule__CatkinPackage__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:429:1: ( ( () ) ) + // InternalRos1Parser.g:430:1: ( () ) + { + // InternalRos1Parser.g:430:1: ( () ) + // InternalRos1Parser.g:431:2: () + { + before(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); + // InternalRos1Parser.g:432:2: () + // InternalRos1Parser.g:432:3: + { + } + + after(grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__0__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__1" + // InternalRos1Parser.g:440:1: rule__CatkinPackage__Group__1 : rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 ; + public final void rule__CatkinPackage__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:444:1: ( rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 ) + // InternalRos1Parser.g:445:2: rule__CatkinPackage__Group__1__Impl rule__CatkinPackage__Group__2 + { + pushFollow(FOLLOW_4); + rule__CatkinPackage__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__1" + + + // $ANTLR start "rule__CatkinPackage__Group__1__Impl" + // InternalRos1Parser.g:452:1: rule__CatkinPackage__Group__1__Impl : ( ( rule__CatkinPackage__NameAssignment_1 ) ) ; + public final void rule__CatkinPackage__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:456:1: ( ( ( rule__CatkinPackage__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:457:1: ( ( rule__CatkinPackage__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:457:1: ( ( rule__CatkinPackage__NameAssignment_1 ) ) + // InternalRos1Parser.g:458:2: ( rule__CatkinPackage__NameAssignment_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getNameAssignment_1()); + // InternalRos1Parser.g:459:2: ( rule__CatkinPackage__NameAssignment_1 ) + // InternalRos1Parser.g:459:3: rule__CatkinPackage__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getCatkinPackageAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__1__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__2" + // InternalRos1Parser.g:467:1: rule__CatkinPackage__Group__2 : rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 ; + public final void rule__CatkinPackage__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:471:1: ( rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 ) + // InternalRos1Parser.g:472:2: rule__CatkinPackage__Group__2__Impl rule__CatkinPackage__Group__3 + { + pushFollow(FOLLOW_5); + rule__CatkinPackage__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__2" + + + // $ANTLR start "rule__CatkinPackage__Group__2__Impl" + // InternalRos1Parser.g:479:1: rule__CatkinPackage__Group__2__Impl : ( Colon ) ; + public final void rule__CatkinPackage__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:483:1: ( ( Colon ) ) + // InternalRos1Parser.g:484:1: ( Colon ) + { + // InternalRos1Parser.g:484:1: ( Colon ) + // InternalRos1Parser.g:485:2: Colon + { + before(grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__2__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__3" + // InternalRos1Parser.g:494:1: rule__CatkinPackage__Group__3 : rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 ; + public final void rule__CatkinPackage__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:498:1: ( rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 ) + // InternalRos1Parser.g:499:2: rule__CatkinPackage__Group__3__Impl rule__CatkinPackage__Group__4 + { + pushFollow(FOLLOW_6); + rule__CatkinPackage__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__3" + + + // $ANTLR start "rule__CatkinPackage__Group__3__Impl" + // InternalRos1Parser.g:506:1: rule__CatkinPackage__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__CatkinPackage__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:510:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:511:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:511:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:512:2: RULE_BEGIN + { + before(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__3__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__4" + // InternalRos1Parser.g:521:1: rule__CatkinPackage__Group__4 : rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 ; + public final void rule__CatkinPackage__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:525:1: ( rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 ) + // InternalRos1Parser.g:526:2: rule__CatkinPackage__Group__4__Impl rule__CatkinPackage__Group__5 + { + pushFollow(FOLLOW_6); + rule__CatkinPackage__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__4" + + + // $ANTLR start "rule__CatkinPackage__Group__4__Impl" + // InternalRos1Parser.g:533:1: rule__CatkinPackage__Group__4__Impl : ( ( rule__CatkinPackage__Group_4__0 )? ) ; + public final void rule__CatkinPackage__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:537:1: ( ( ( rule__CatkinPackage__Group_4__0 )? ) ) + // InternalRos1Parser.g:538:1: ( ( rule__CatkinPackage__Group_4__0 )? ) + { + // InternalRos1Parser.g:538:1: ( ( rule__CatkinPackage__Group_4__0 )? ) + // InternalRos1Parser.g:539:2: ( rule__CatkinPackage__Group_4__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_4()); + // InternalRos1Parser.g:540:2: ( rule__CatkinPackage__Group_4__0 )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==FromGitRepo) ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalRos1Parser.g:540:3: rule__CatkinPackage__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getCatkinPackageAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__4__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__5" + // InternalRos1Parser.g:548:1: rule__CatkinPackage__Group__5 : rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 ; + public final void rule__CatkinPackage__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:552:1: ( rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 ) + // InternalRos1Parser.g:553:2: rule__CatkinPackage__Group__5__Impl rule__CatkinPackage__Group__6 + { + pushFollow(FOLLOW_6); + rule__CatkinPackage__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__5" + + + // $ANTLR start "rule__CatkinPackage__Group__5__Impl" + // InternalRos1Parser.g:560:1: rule__CatkinPackage__Group__5__Impl : ( ( rule__CatkinPackage__Group_5__0 )? ) ; + public final void rule__CatkinPackage__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:564:1: ( ( ( rule__CatkinPackage__Group_5__0 )? ) ) + // InternalRos1Parser.g:565:1: ( ( rule__CatkinPackage__Group_5__0 )? ) + { + // InternalRos1Parser.g:565:1: ( ( rule__CatkinPackage__Group_5__0 )? ) + // InternalRos1Parser.g:566:2: ( rule__CatkinPackage__Group_5__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_5()); + // InternalRos1Parser.g:567:2: ( rule__CatkinPackage__Group_5__0 )? + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==Artifacts) ) { + alt5=1; + } + switch (alt5) { + case 1 : + // InternalRos1Parser.g:567:3: rule__CatkinPackage__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getCatkinPackageAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__5__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__6" + // InternalRos1Parser.g:575:1: rule__CatkinPackage__Group__6 : rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 ; + public final void rule__CatkinPackage__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:579:1: ( rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 ) + // InternalRos1Parser.g:580:2: rule__CatkinPackage__Group__6__Impl rule__CatkinPackage__Group__7 + { + pushFollow(FOLLOW_6); + rule__CatkinPackage__Group__6__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__7(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__6" + + + // $ANTLR start "rule__CatkinPackage__Group__6__Impl" + // InternalRos1Parser.g:587:1: rule__CatkinPackage__Group__6__Impl : ( ( rule__CatkinPackage__Group_6__0 )? ) ; + public final void rule__CatkinPackage__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:591:1: ( ( ( rule__CatkinPackage__Group_6__0 )? ) ) + // InternalRos1Parser.g:592:1: ( ( rule__CatkinPackage__Group_6__0 )? ) + { + // InternalRos1Parser.g:592:1: ( ( rule__CatkinPackage__Group_6__0 )? ) + // InternalRos1Parser.g:593:2: ( rule__CatkinPackage__Group_6__0 )? + { + before(grammarAccess.getCatkinPackageAccess().getGroup_6()); + // InternalRos1Parser.g:594:2: ( rule__CatkinPackage__Group_6__0 )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==Dependencies) ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalRos1Parser.g:594:3: rule__CatkinPackage__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getCatkinPackageAccess().getGroup_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__6__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group__7" + // InternalRos1Parser.g:602:1: rule__CatkinPackage__Group__7 : rule__CatkinPackage__Group__7__Impl ; + public final void rule__CatkinPackage__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:606:1: ( rule__CatkinPackage__Group__7__Impl ) + // InternalRos1Parser.g:607:2: rule__CatkinPackage__Group__7__Impl + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group__7__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__7" + + + // $ANTLR start "rule__CatkinPackage__Group__7__Impl" + // InternalRos1Parser.g:613:1: rule__CatkinPackage__Group__7__Impl : ( RULE_END ) ; + public final void rule__CatkinPackage__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:617:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:618:1: ( RULE_END ) + { + // InternalRos1Parser.g:618:1: ( RULE_END ) + // InternalRos1Parser.g:619:2: RULE_END + { + before(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group__7__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_4__0" + // InternalRos1Parser.g:629:1: rule__CatkinPackage__Group_4__0 : rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 ; + public final void rule__CatkinPackage__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:633:1: ( rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 ) + // InternalRos1Parser.g:634:2: rule__CatkinPackage__Group_4__0__Impl rule__CatkinPackage__Group_4__1 + { + pushFollow(FOLLOW_7); + rule__CatkinPackage__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_4__0" + + + // $ANTLR start "rule__CatkinPackage__Group_4__0__Impl" + // InternalRos1Parser.g:641:1: rule__CatkinPackage__Group_4__0__Impl : ( FromGitRepo ) ; + public final void rule__CatkinPackage__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:645:1: ( ( FromGitRepo ) ) + // InternalRos1Parser.g:646:1: ( FromGitRepo ) + { + // InternalRos1Parser.g:646:1: ( FromGitRepo ) + // InternalRos1Parser.g:647:2: FromGitRepo + { + before(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + match(input,FromGitRepo,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_4__0__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_4__1" + // InternalRos1Parser.g:656:1: rule__CatkinPackage__Group_4__1 : rule__CatkinPackage__Group_4__1__Impl ; + public final void rule__CatkinPackage__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:660:1: ( rule__CatkinPackage__Group_4__1__Impl ) + // InternalRos1Parser.g:661:2: rule__CatkinPackage__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_4__1" + + + // $ANTLR start "rule__CatkinPackage__Group_4__1__Impl" + // InternalRos1Parser.g:667:1: rule__CatkinPackage__Group_4__1__Impl : ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) ; + public final void rule__CatkinPackage__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:671:1: ( ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) ) + // InternalRos1Parser.g:672:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) + { + // InternalRos1Parser.g:672:1: ( ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) ) + // InternalRos1Parser.g:673:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); + // InternalRos1Parser.g:674:2: ( rule__CatkinPackage__FromGitRepoAssignment_4_1 ) + // InternalRos1Parser.g:674:3: rule__CatkinPackage__FromGitRepoAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__FromGitRepoAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getCatkinPackageAccess().getFromGitRepoAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_4__1__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_5__0" + // InternalRos1Parser.g:683:1: rule__CatkinPackage__Group_5__0 : rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 ; + public final void rule__CatkinPackage__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:687:1: ( rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 ) + // InternalRos1Parser.g:688:2: rule__CatkinPackage__Group_5__0__Impl rule__CatkinPackage__Group_5__1 + { + pushFollow(FOLLOW_5); + rule__CatkinPackage__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__0" + + + // $ANTLR start "rule__CatkinPackage__Group_5__0__Impl" + // InternalRos1Parser.g:695:1: rule__CatkinPackage__Group_5__0__Impl : ( Artifacts ) ; + public final void rule__CatkinPackage__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:699:1: ( ( Artifacts ) ) + // InternalRos1Parser.g:700:1: ( Artifacts ) + { + // InternalRos1Parser.g:700:1: ( Artifacts ) + // InternalRos1Parser.g:701:2: Artifacts + { + before(grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); + match(input,Artifacts,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__0__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_5__1" + // InternalRos1Parser.g:710:1: rule__CatkinPackage__Group_5__1 : rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 ; + public final void rule__CatkinPackage__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:714:1: ( rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 ) + // InternalRos1Parser.g:715:2: rule__CatkinPackage__Group_5__1__Impl rule__CatkinPackage__Group_5__2 + { + pushFollow(FOLLOW_8); + rule__CatkinPackage__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__1" + + + // $ANTLR start "rule__CatkinPackage__Group_5__1__Impl" + // InternalRos1Parser.g:722:1: rule__CatkinPackage__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__CatkinPackage__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:726:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:727:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:727:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:728:2: RULE_BEGIN + { + before(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__1__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_5__2" + // InternalRos1Parser.g:737:1: rule__CatkinPackage__Group_5__2 : rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 ; + public final void rule__CatkinPackage__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:741:1: ( rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 ) + // InternalRos1Parser.g:742:2: rule__CatkinPackage__Group_5__2__Impl rule__CatkinPackage__Group_5__3 + { + pushFollow(FOLLOW_8); + rule__CatkinPackage__Group_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__2" + + + // $ANTLR start "rule__CatkinPackage__Group_5__2__Impl" + // InternalRos1Parser.g:749:1: rule__CatkinPackage__Group_5__2__Impl : ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) ; + public final void rule__CatkinPackage__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:753:1: ( ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) ) + // InternalRos1Parser.g:754:1: ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) + { + // InternalRos1Parser.g:754:1: ( ( rule__CatkinPackage__ArtifactAssignment_5_2 )* ) + // InternalRos1Parser.g:755:2: ( rule__CatkinPackage__ArtifactAssignment_5_2 )* + { + before(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2()); + // InternalRos1Parser.g:756:2: ( rule__CatkinPackage__ArtifactAssignment_5_2 )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==Node||(LA7_0>=RULE_ID && LA7_0<=RULE_ROS_CONVENTION_A)) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos1Parser.g:756:3: rule__CatkinPackage__ArtifactAssignment_5_2 + { + pushFollow(FOLLOW_9); + rule__CatkinPackage__ArtifactAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop7; + } + } while (true); + + after(grammarAccess.getCatkinPackageAccess().getArtifactAssignment_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__2__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_5__3" + // InternalRos1Parser.g:764:1: rule__CatkinPackage__Group_5__3 : rule__CatkinPackage__Group_5__3__Impl ; + public final void rule__CatkinPackage__Group_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:768:1: ( rule__CatkinPackage__Group_5__3__Impl ) + // InternalRos1Parser.g:769:2: rule__CatkinPackage__Group_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__3" + + + // $ANTLR start "rule__CatkinPackage__Group_5__3__Impl" + // InternalRos1Parser.g:775:1: rule__CatkinPackage__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__CatkinPackage__Group_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:779:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:780:1: ( RULE_END ) + { + // InternalRos1Parser.g:780:1: ( RULE_END ) + // InternalRos1Parser.g:781:2: RULE_END + { + before(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_5__3__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6__0" + // InternalRos1Parser.g:791:1: rule__CatkinPackage__Group_6__0 : rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 ; + public final void rule__CatkinPackage__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:795:1: ( rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 ) + // InternalRos1Parser.g:796:2: rule__CatkinPackage__Group_6__0__Impl rule__CatkinPackage__Group_6__1 + { + pushFollow(FOLLOW_10); + rule__CatkinPackage__Group_6__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__0" + + + // $ANTLR start "rule__CatkinPackage__Group_6__0__Impl" + // InternalRos1Parser.g:803:1: rule__CatkinPackage__Group_6__0__Impl : ( Dependencies ) ; + public final void rule__CatkinPackage__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:807:1: ( ( Dependencies ) ) + // InternalRos1Parser.g:808:1: ( Dependencies ) + { + // InternalRos1Parser.g:808:1: ( Dependencies ) + // InternalRos1Parser.g:809:2: Dependencies + { + before(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); + match(input,Dependencies,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__0__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6__1" + // InternalRos1Parser.g:818:1: rule__CatkinPackage__Group_6__1 : rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 ; + public final void rule__CatkinPackage__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:822:1: ( rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 ) + // InternalRos1Parser.g:823:2: rule__CatkinPackage__Group_6__1__Impl rule__CatkinPackage__Group_6__2 + { + pushFollow(FOLLOW_11); + rule__CatkinPackage__Group_6__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__1" + + + // $ANTLR start "rule__CatkinPackage__Group_6__1__Impl" + // InternalRos1Parser.g:830:1: rule__CatkinPackage__Group_6__1__Impl : ( LeftSquareBracket ) ; + public final void rule__CatkinPackage__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:834:1: ( ( LeftSquareBracket ) ) + // InternalRos1Parser.g:835:1: ( LeftSquareBracket ) + { + // InternalRos1Parser.g:835:1: ( LeftSquareBracket ) + // InternalRos1Parser.g:836:2: LeftSquareBracket + { + before(grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); + match(input,LeftSquareBracket,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__1__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6__2" + // InternalRos1Parser.g:845:1: rule__CatkinPackage__Group_6__2 : rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 ; + public final void rule__CatkinPackage__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:849:1: ( rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 ) + // InternalRos1Parser.g:850:2: rule__CatkinPackage__Group_6__2__Impl rule__CatkinPackage__Group_6__3 + { + pushFollow(FOLLOW_12); + rule__CatkinPackage__Group_6__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__2" + + + // $ANTLR start "rule__CatkinPackage__Group_6__2__Impl" + // InternalRos1Parser.g:857:1: rule__CatkinPackage__Group_6__2__Impl : ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) ; + public final void rule__CatkinPackage__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:861:1: ( ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) ) + // InternalRos1Parser.g:862:1: ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) + { + // InternalRos1Parser.g:862:1: ( ( rule__CatkinPackage__DependencyAssignment_6_2 ) ) + // InternalRos1Parser.g:863:2: ( rule__CatkinPackage__DependencyAssignment_6_2 ) + { + before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2()); + // InternalRos1Parser.g:864:2: ( rule__CatkinPackage__DependencyAssignment_6_2 ) + // InternalRos1Parser.g:864:3: rule__CatkinPackage__DependencyAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__DependencyAssignment_6_2(); + + state._fsp--; + + + } + + after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__2__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6__3" + // InternalRos1Parser.g:872:1: rule__CatkinPackage__Group_6__3 : rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 ; + public final void rule__CatkinPackage__Group_6__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:876:1: ( rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 ) + // InternalRos1Parser.g:877:2: rule__CatkinPackage__Group_6__3__Impl rule__CatkinPackage__Group_6__4 + { + pushFollow(FOLLOW_12); + rule__CatkinPackage__Group_6__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__3" + + + // $ANTLR start "rule__CatkinPackage__Group_6__3__Impl" + // InternalRos1Parser.g:884:1: rule__CatkinPackage__Group_6__3__Impl : ( ( rule__CatkinPackage__Group_6_3__0 )* ) ; + public final void rule__CatkinPackage__Group_6__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:888:1: ( ( ( rule__CatkinPackage__Group_6_3__0 )* ) ) + // InternalRos1Parser.g:889:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) + { + // InternalRos1Parser.g:889:1: ( ( rule__CatkinPackage__Group_6_3__0 )* ) + // InternalRos1Parser.g:890:2: ( rule__CatkinPackage__Group_6_3__0 )* + { + before(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); + // InternalRos1Parser.g:891:2: ( rule__CatkinPackage__Group_6_3__0 )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==Comma) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalRos1Parser.g:891:3: rule__CatkinPackage__Group_6_3__0 + { + pushFollow(FOLLOW_13); + rule__CatkinPackage__Group_6_3__0(); + + state._fsp--; + + + } + break; + + default : + break loop8; + } + } while (true); + + after(grammarAccess.getCatkinPackageAccess().getGroup_6_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__3__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6__4" + // InternalRos1Parser.g:899:1: rule__CatkinPackage__Group_6__4 : rule__CatkinPackage__Group_6__4__Impl ; + public final void rule__CatkinPackage__Group_6__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:903:1: ( rule__CatkinPackage__Group_6__4__Impl ) + // InternalRos1Parser.g:904:2: rule__CatkinPackage__Group_6__4__Impl + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__4" + + + // $ANTLR start "rule__CatkinPackage__Group_6__4__Impl" + // InternalRos1Parser.g:910:1: rule__CatkinPackage__Group_6__4__Impl : ( RightSquareBracket ) ; + public final void rule__CatkinPackage__Group_6__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:914:1: ( ( RightSquareBracket ) ) + // InternalRos1Parser.g:915:1: ( RightSquareBracket ) + { + // InternalRos1Parser.g:915:1: ( RightSquareBracket ) + // InternalRos1Parser.g:916:2: RightSquareBracket + { + before(grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); + match(input,RightSquareBracket,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6__4__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6_3__0" + // InternalRos1Parser.g:926:1: rule__CatkinPackage__Group_6_3__0 : rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 ; + public final void rule__CatkinPackage__Group_6_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:930:1: ( rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 ) + // InternalRos1Parser.g:931:2: rule__CatkinPackage__Group_6_3__0__Impl rule__CatkinPackage__Group_6_3__1 + { + pushFollow(FOLLOW_11); + rule__CatkinPackage__Group_6_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6_3__0" + + + // $ANTLR start "rule__CatkinPackage__Group_6_3__0__Impl" + // InternalRos1Parser.g:938:1: rule__CatkinPackage__Group_6_3__0__Impl : ( Comma ) ; + public final void rule__CatkinPackage__Group_6_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:942:1: ( ( Comma ) ) + // InternalRos1Parser.g:943:1: ( Comma ) + { + // InternalRos1Parser.g:943:1: ( Comma ) + // InternalRos1Parser.g:944:2: Comma + { + before(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + match(input,Comma,FOLLOW_2); + after(grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6_3__0__Impl" + + + // $ANTLR start "rule__CatkinPackage__Group_6_3__1" + // InternalRos1Parser.g:953:1: rule__CatkinPackage__Group_6_3__1 : rule__CatkinPackage__Group_6_3__1__Impl ; + public final void rule__CatkinPackage__Group_6_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:957:1: ( rule__CatkinPackage__Group_6_3__1__Impl ) + // InternalRos1Parser.g:958:2: rule__CatkinPackage__Group_6_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__Group_6_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6_3__1" + + + // $ANTLR start "rule__CatkinPackage__Group_6_3__1__Impl" + // InternalRos1Parser.g:964:1: rule__CatkinPackage__Group_6_3__1__Impl : ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) ; + public final void rule__CatkinPackage__Group_6_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:968:1: ( ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) ) + // InternalRos1Parser.g:969:1: ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) + { + // InternalRos1Parser.g:969:1: ( ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) ) + // InternalRos1Parser.g:970:2: ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) + { + before(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1()); + // InternalRos1Parser.g:971:2: ( rule__CatkinPackage__DependencyAssignment_6_3_1 ) + // InternalRos1Parser.g:971:3: rule__CatkinPackage__DependencyAssignment_6_3_1 + { + pushFollow(FOLLOW_2); + rule__CatkinPackage__DependencyAssignment_6_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getCatkinPackageAccess().getDependencyAssignment_6_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__Group_6_3__1__Impl" + + + // $ANTLR start "rule__Artifact__Group__0" + // InternalRos1Parser.g:980:1: rule__Artifact__Group__0 : rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ; + public final void rule__Artifact__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:984:1: ( rule__Artifact__Group__0__Impl rule__Artifact__Group__1 ) + // InternalRos1Parser.g:985:2: rule__Artifact__Group__0__Impl rule__Artifact__Group__1 + { + pushFollow(FOLLOW_3); + rule__Artifact__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Artifact__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__0" + + + // $ANTLR start "rule__Artifact__Group__0__Impl" + // InternalRos1Parser.g:992:1: rule__Artifact__Group__0__Impl : ( () ) ; + public final void rule__Artifact__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:996:1: ( ( () ) ) + // InternalRos1Parser.g:997:1: ( () ) + { + // InternalRos1Parser.g:997:1: ( () ) + // InternalRos1Parser.g:998:2: () + { + before(grammarAccess.getArtifactAccess().getArtifactAction_0()); + // InternalRos1Parser.g:999:2: () + // InternalRos1Parser.g:999:3: + { + } + + after(grammarAccess.getArtifactAccess().getArtifactAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__0__Impl" + + + // $ANTLR start "rule__Artifact__Group__1" + // InternalRos1Parser.g:1007:1: rule__Artifact__Group__1 : rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ; + public final void rule__Artifact__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1011:1: ( rule__Artifact__Group__1__Impl rule__Artifact__Group__2 ) + // InternalRos1Parser.g:1012:2: rule__Artifact__Group__1__Impl rule__Artifact__Group__2 + { + pushFollow(FOLLOW_4); + rule__Artifact__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Artifact__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__1" + + + // $ANTLR start "rule__Artifact__Group__1__Impl" + // InternalRos1Parser.g:1019:1: rule__Artifact__Group__1__Impl : ( ( rule__Artifact__NameAssignment_1 ) ) ; + public final void rule__Artifact__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1023:1: ( ( ( rule__Artifact__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:1024:1: ( ( rule__Artifact__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:1024:1: ( ( rule__Artifact__NameAssignment_1 ) ) + // InternalRos1Parser.g:1025:2: ( rule__Artifact__NameAssignment_1 ) + { + before(grammarAccess.getArtifactAccess().getNameAssignment_1()); + // InternalRos1Parser.g:1026:2: ( rule__Artifact__NameAssignment_1 ) + // InternalRos1Parser.g:1026:3: rule__Artifact__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Artifact__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getArtifactAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__1__Impl" + + + // $ANTLR start "rule__Artifact__Group__2" + // InternalRos1Parser.g:1034:1: rule__Artifact__Group__2 : rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ; + public final void rule__Artifact__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1038:1: ( rule__Artifact__Group__2__Impl rule__Artifact__Group__3 ) + // InternalRos1Parser.g:1039:2: rule__Artifact__Group__2__Impl rule__Artifact__Group__3 + { + pushFollow(FOLLOW_5); + rule__Artifact__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Artifact__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__2" + + + // $ANTLR start "rule__Artifact__Group__2__Impl" + // InternalRos1Parser.g:1046:1: rule__Artifact__Group__2__Impl : ( Colon ) ; + public final void rule__Artifact__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1050:1: ( ( Colon ) ) + // InternalRos1Parser.g:1051:1: ( Colon ) + { + // InternalRos1Parser.g:1051:1: ( Colon ) + // InternalRos1Parser.g:1052:2: Colon + { + before(grammarAccess.getArtifactAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__2__Impl" + + + // $ANTLR start "rule__Artifact__Group__3" + // InternalRos1Parser.g:1061:1: rule__Artifact__Group__3 : rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ; + public final void rule__Artifact__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1065:1: ( rule__Artifact__Group__3__Impl rule__Artifact__Group__4 ) + // InternalRos1Parser.g:1066:2: rule__Artifact__Group__3__Impl rule__Artifact__Group__4 + { + pushFollow(FOLLOW_14); + rule__Artifact__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Artifact__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__3" + + + // $ANTLR start "rule__Artifact__Group__3__Impl" + // InternalRos1Parser.g:1073:1: rule__Artifact__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Artifact__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1077:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1078:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1078:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1079:2: RULE_BEGIN + { + before(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__3__Impl" + + + // $ANTLR start "rule__Artifact__Group__4" + // InternalRos1Parser.g:1088:1: rule__Artifact__Group__4 : rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ; + public final void rule__Artifact__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1092:1: ( rule__Artifact__Group__4__Impl rule__Artifact__Group__5 ) + // InternalRos1Parser.g:1093:2: rule__Artifact__Group__4__Impl rule__Artifact__Group__5 + { + pushFollow(FOLLOW_14); + rule__Artifact__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Artifact__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__4" + + + // $ANTLR start "rule__Artifact__Group__4__Impl" + // InternalRos1Parser.g:1100:1: rule__Artifact__Group__4__Impl : ( ( rule__Artifact__NodeAssignment_4 )? ) ; + public final void rule__Artifact__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1104:1: ( ( ( rule__Artifact__NodeAssignment_4 )? ) ) + // InternalRos1Parser.g:1105:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + { + // InternalRos1Parser.g:1105:1: ( ( rule__Artifact__NodeAssignment_4 )? ) + // InternalRos1Parser.g:1106:2: ( rule__Artifact__NodeAssignment_4 )? + { + before(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + // InternalRos1Parser.g:1107:2: ( rule__Artifact__NodeAssignment_4 )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==Node_1) ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalRos1Parser.g:1107:3: rule__Artifact__NodeAssignment_4 + { + pushFollow(FOLLOW_2); + rule__Artifact__NodeAssignment_4(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getArtifactAccess().getNodeAssignment_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__4__Impl" + + + // $ANTLR start "rule__Artifact__Group__5" + // InternalRos1Parser.g:1115:1: rule__Artifact__Group__5 : rule__Artifact__Group__5__Impl ; + public final void rule__Artifact__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1119:1: ( rule__Artifact__Group__5__Impl ) + // InternalRos1Parser.g:1120:2: rule__Artifact__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__Artifact__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__5" + + + // $ANTLR start "rule__Artifact__Group__5__Impl" + // InternalRos1Parser.g:1126:1: rule__Artifact__Group__5__Impl : ( RULE_END ) ; + public final void rule__Artifact__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1130:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1131:1: ( RULE_END ) + { + // InternalRos1Parser.g:1131:1: ( RULE_END ) + // InternalRos1Parser.g:1132:2: RULE_END + { + before(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__Group__5__Impl" + + + // $ANTLR start "rule__Node__Group__0" + // InternalRos1Parser.g:1142:1: rule__Node__Group__0 : rule__Node__Group__0__Impl rule__Node__Group__1 ; + public final void rule__Node__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1146:1: ( rule__Node__Group__0__Impl rule__Node__Group__1 ) + // InternalRos1Parser.g:1147:2: rule__Node__Group__0__Impl rule__Node__Group__1 + { + pushFollow(FOLLOW_3); + rule__Node__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__0" + + + // $ANTLR start "rule__Node__Group__0__Impl" + // InternalRos1Parser.g:1154:1: rule__Node__Group__0__Impl : ( Node_1 ) ; + public final void rule__Node__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1158:1: ( ( Node_1 ) ) + // InternalRos1Parser.g:1159:1: ( Node_1 ) + { + // InternalRos1Parser.g:1159:1: ( Node_1 ) + // InternalRos1Parser.g:1160:2: Node_1 + { + before(grammarAccess.getNodeAccess().getNodeKeyword_0()); + match(input,Node_1,FOLLOW_2); + after(grammarAccess.getNodeAccess().getNodeKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__0__Impl" + + + // $ANTLR start "rule__Node__Group__1" + // InternalRos1Parser.g:1169:1: rule__Node__Group__1 : rule__Node__Group__1__Impl rule__Node__Group__2 ; + public final void rule__Node__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1173:1: ( rule__Node__Group__1__Impl rule__Node__Group__2 ) + // InternalRos1Parser.g:1174:2: rule__Node__Group__1__Impl rule__Node__Group__2 + { + pushFollow(FOLLOW_5); + rule__Node__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__1" + + + // $ANTLR start "rule__Node__Group__1__Impl" + // InternalRos1Parser.g:1181:1: rule__Node__Group__1__Impl : ( ( rule__Node__NameAssignment_1 ) ) ; + public final void rule__Node__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1185:1: ( ( ( rule__Node__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:1186:1: ( ( rule__Node__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:1186:1: ( ( rule__Node__NameAssignment_1 ) ) + // InternalRos1Parser.g:1187:2: ( rule__Node__NameAssignment_1 ) + { + before(grammarAccess.getNodeAccess().getNameAssignment_1()); + // InternalRos1Parser.g:1188:2: ( rule__Node__NameAssignment_1 ) + // InternalRos1Parser.g:1188:3: rule__Node__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Node__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getNodeAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__1__Impl" + + + // $ANTLR start "rule__Node__Group__2" + // InternalRos1Parser.g:1196:1: rule__Node__Group__2 : rule__Node__Group__2__Impl rule__Node__Group__3 ; + public final void rule__Node__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1200:1: ( rule__Node__Group__2__Impl rule__Node__Group__3 ) + // InternalRos1Parser.g:1201:2: rule__Node__Group__2__Impl rule__Node__Group__3 + { + pushFollow(FOLLOW_15); + rule__Node__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__2" + + + // $ANTLR start "rule__Node__Group__2__Impl" + // InternalRos1Parser.g:1208:1: rule__Node__Group__2__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1212:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1213:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1213:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1214:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__2__Impl" + + + // $ANTLR start "rule__Node__Group__3" + // InternalRos1Parser.g:1223:1: rule__Node__Group__3 : rule__Node__Group__3__Impl rule__Node__Group__4 ; + public final void rule__Node__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1227:1: ( rule__Node__Group__3__Impl rule__Node__Group__4 ) + // InternalRos1Parser.g:1228:2: rule__Node__Group__3__Impl rule__Node__Group__4 + { + pushFollow(FOLLOW_15); + rule__Node__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__3" + + + // $ANTLR start "rule__Node__Group__3__Impl" + // InternalRos1Parser.g:1235:1: rule__Node__Group__3__Impl : ( ( rule__Node__Group_3__0 )? ) ; + public final void rule__Node__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1239:1: ( ( ( rule__Node__Group_3__0 )? ) ) + // InternalRos1Parser.g:1240:1: ( ( rule__Node__Group_3__0 )? ) + { + // InternalRos1Parser.g:1240:1: ( ( rule__Node__Group_3__0 )? ) + // InternalRos1Parser.g:1241:2: ( rule__Node__Group_3__0 )? + { + before(grammarAccess.getNodeAccess().getGroup_3()); + // InternalRos1Parser.g:1242:2: ( rule__Node__Group_3__0 )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==Publishers) ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos1Parser.g:1242:3: rule__Node__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_3__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getNodeAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__3__Impl" + + + // $ANTLR start "rule__Node__Group__4" + // InternalRos1Parser.g:1250:1: rule__Node__Group__4 : rule__Node__Group__4__Impl rule__Node__Group__5 ; + public final void rule__Node__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1254:1: ( rule__Node__Group__4__Impl rule__Node__Group__5 ) + // InternalRos1Parser.g:1255:2: rule__Node__Group__4__Impl rule__Node__Group__5 + { + pushFollow(FOLLOW_15); + rule__Node__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__4" + + + // $ANTLR start "rule__Node__Group__4__Impl" + // InternalRos1Parser.g:1262:1: rule__Node__Group__4__Impl : ( ( rule__Node__Group_4__0 )? ) ; + public final void rule__Node__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1266:1: ( ( ( rule__Node__Group_4__0 )? ) ) + // InternalRos1Parser.g:1267:1: ( ( rule__Node__Group_4__0 )? ) + { + // InternalRos1Parser.g:1267:1: ( ( rule__Node__Group_4__0 )? ) + // InternalRos1Parser.g:1268:2: ( rule__Node__Group_4__0 )? + { + before(grammarAccess.getNodeAccess().getGroup_4()); + // InternalRos1Parser.g:1269:2: ( rule__Node__Group_4__0 )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==Subscribers) ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalRos1Parser.g:1269:3: rule__Node__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getNodeAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__4__Impl" + + + // $ANTLR start "rule__Node__Group__5" + // InternalRos1Parser.g:1277:1: rule__Node__Group__5 : rule__Node__Group__5__Impl rule__Node__Group__6 ; + public final void rule__Node__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1281:1: ( rule__Node__Group__5__Impl rule__Node__Group__6 ) + // InternalRos1Parser.g:1282:2: rule__Node__Group__5__Impl rule__Node__Group__6 + { + pushFollow(FOLLOW_15); + rule__Node__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__5" + + + // $ANTLR start "rule__Node__Group__5__Impl" + // InternalRos1Parser.g:1289:1: rule__Node__Group__5__Impl : ( ( rule__Node__Group_5__0 )? ) ; + public final void rule__Node__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1293:1: ( ( ( rule__Node__Group_5__0 )? ) ) + // InternalRos1Parser.g:1294:1: ( ( rule__Node__Group_5__0 )? ) + { + // InternalRos1Parser.g:1294:1: ( ( rule__Node__Group_5__0 )? ) + // InternalRos1Parser.g:1295:2: ( rule__Node__Group_5__0 )? + { + before(grammarAccess.getNodeAccess().getGroup_5()); + // InternalRos1Parser.g:1296:2: ( rule__Node__Group_5__0 )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==Parameters) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // InternalRos1Parser.g:1296:3: rule__Node__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__Node__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getNodeAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__5__Impl" + + + // $ANTLR start "rule__Node__Group__6" + // InternalRos1Parser.g:1304:1: rule__Node__Group__6 : rule__Node__Group__6__Impl ; + public final void rule__Node__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1308:1: ( rule__Node__Group__6__Impl ) + // InternalRos1Parser.g:1309:2: rule__Node__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__6" + + + // $ANTLR start "rule__Node__Group__6__Impl" + // InternalRos1Parser.g:1315:1: rule__Node__Group__6__Impl : ( RULE_END ) ; + public final void rule__Node__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1319:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1320:1: ( RULE_END ) + { + // InternalRos1Parser.g:1320:1: ( RULE_END ) + // InternalRos1Parser.g:1321:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group__6__Impl" + + + // $ANTLR start "rule__Node__Group_3__0" + // InternalRos1Parser.g:1331:1: rule__Node__Group_3__0 : rule__Node__Group_3__0__Impl rule__Node__Group_3__1 ; + public final void rule__Node__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1335:1: ( rule__Node__Group_3__0__Impl rule__Node__Group_3__1 ) + // InternalRos1Parser.g:1336:2: rule__Node__Group_3__0__Impl rule__Node__Group_3__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__0" + + + // $ANTLR start "rule__Node__Group_3__0__Impl" + // InternalRos1Parser.g:1343:1: rule__Node__Group_3__0__Impl : ( Publishers ) ; + public final void rule__Node__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1347:1: ( ( Publishers ) ) + // InternalRos1Parser.g:1348:1: ( Publishers ) + { + // InternalRos1Parser.g:1348:1: ( Publishers ) + // InternalRos1Parser.g:1349:2: Publishers + { + before(grammarAccess.getNodeAccess().getPublishersKeyword_3_0()); + match(input,Publishers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getPublishersKeyword_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__0__Impl" + + + // $ANTLR start "rule__Node__Group_3__1" + // InternalRos1Parser.g:1358:1: rule__Node__Group_3__1 : rule__Node__Group_3__1__Impl rule__Node__Group_3__2 ; + public final void rule__Node__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1362:1: ( rule__Node__Group_3__1__Impl rule__Node__Group_3__2 ) + // InternalRos1Parser.g:1363:2: rule__Node__Group_3__1__Impl rule__Node__Group_3__2 + { + pushFollow(FOLLOW_16); + rule__Node__Group_3__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__1" + + + // $ANTLR start "rule__Node__Group_3__1__Impl" + // InternalRos1Parser.g:1370:1: rule__Node__Group_3__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1374:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1375:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1375:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1376:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__1__Impl" + + + // $ANTLR start "rule__Node__Group_3__2" + // InternalRos1Parser.g:1385:1: rule__Node__Group_3__2 : rule__Node__Group_3__2__Impl rule__Node__Group_3__3 ; + public final void rule__Node__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1389:1: ( rule__Node__Group_3__2__Impl rule__Node__Group_3__3 ) + // InternalRos1Parser.g:1390:2: rule__Node__Group_3__2__Impl rule__Node__Group_3__3 + { + pushFollow(FOLLOW_16); + rule__Node__Group_3__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_3__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__2" + + + // $ANTLR start "rule__Node__Group_3__2__Impl" + // InternalRos1Parser.g:1397:1: rule__Node__Group_3__2__Impl : ( ( rule__Node__PublisherAssignment_3_2 )* ) ; + public final void rule__Node__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1401:1: ( ( ( rule__Node__PublisherAssignment_3_2 )* ) ) + // InternalRos1Parser.g:1402:1: ( ( rule__Node__PublisherAssignment_3_2 )* ) + { + // InternalRos1Parser.g:1402:1: ( ( rule__Node__PublisherAssignment_3_2 )* ) + // InternalRos1Parser.g:1403:2: ( rule__Node__PublisherAssignment_3_2 )* + { + before(grammarAccess.getNodeAccess().getPublisherAssignment_3_2()); + // InternalRos1Parser.g:1404:2: ( rule__Node__PublisherAssignment_3_2 )* + loop13: + do { + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==RULE_ID||LA13_0==RULE_STRING) ) { + alt13=1; + } + + + switch (alt13) { + case 1 : + // InternalRos1Parser.g:1404:3: rule__Node__PublisherAssignment_3_2 + { + pushFollow(FOLLOW_17); + rule__Node__PublisherAssignment_3_2(); + + state._fsp--; + + + } + break; + + default : + break loop13; + } + } while (true); + + after(grammarAccess.getNodeAccess().getPublisherAssignment_3_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__2__Impl" + + + // $ANTLR start "rule__Node__Group_3__3" + // InternalRos1Parser.g:1412:1: rule__Node__Group_3__3 : rule__Node__Group_3__3__Impl ; + public final void rule__Node__Group_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1416:1: ( rule__Node__Group_3__3__Impl ) + // InternalRos1Parser.g:1417:2: rule__Node__Group_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_3__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__3" + + + // $ANTLR start "rule__Node__Group_3__3__Impl" + // InternalRos1Parser.g:1423:1: rule__Node__Group_3__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1427:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1428:1: ( RULE_END ) + { + // InternalRos1Parser.g:1428:1: ( RULE_END ) + // InternalRos1Parser.g:1429:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_3__3__Impl" + + + // $ANTLR start "rule__Node__Group_4__0" + // InternalRos1Parser.g:1439:1: rule__Node__Group_4__0 : rule__Node__Group_4__0__Impl rule__Node__Group_4__1 ; + public final void rule__Node__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1443:1: ( rule__Node__Group_4__0__Impl rule__Node__Group_4__1 ) + // InternalRos1Parser.g:1444:2: rule__Node__Group_4__0__Impl rule__Node__Group_4__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__0" + + + // $ANTLR start "rule__Node__Group_4__0__Impl" + // InternalRos1Parser.g:1451:1: rule__Node__Group_4__0__Impl : ( Subscribers ) ; + public final void rule__Node__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1455:1: ( ( Subscribers ) ) + // InternalRos1Parser.g:1456:1: ( Subscribers ) + { + // InternalRos1Parser.g:1456:1: ( Subscribers ) + // InternalRos1Parser.g:1457:2: Subscribers + { + before(grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()); + match(input,Subscribers,FOLLOW_2); + after(grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__0__Impl" + + + // $ANTLR start "rule__Node__Group_4__1" + // InternalRos1Parser.g:1466:1: rule__Node__Group_4__1 : rule__Node__Group_4__1__Impl rule__Node__Group_4__2 ; + public final void rule__Node__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1470:1: ( rule__Node__Group_4__1__Impl rule__Node__Group_4__2 ) + // InternalRos1Parser.g:1471:2: rule__Node__Group_4__1__Impl rule__Node__Group_4__2 + { + pushFollow(FOLLOW_16); + rule__Node__Group_4__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_4__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__1" + + + // $ANTLR start "rule__Node__Group_4__1__Impl" + // InternalRos1Parser.g:1478:1: rule__Node__Group_4__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1482:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1483:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1483:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1484:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__1__Impl" + + + // $ANTLR start "rule__Node__Group_4__2" + // InternalRos1Parser.g:1493:1: rule__Node__Group_4__2 : rule__Node__Group_4__2__Impl rule__Node__Group_4__3 ; + public final void rule__Node__Group_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1497:1: ( rule__Node__Group_4__2__Impl rule__Node__Group_4__3 ) + // InternalRos1Parser.g:1498:2: rule__Node__Group_4__2__Impl rule__Node__Group_4__3 + { + pushFollow(FOLLOW_16); + rule__Node__Group_4__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_4__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__2" + + + // $ANTLR start "rule__Node__Group_4__2__Impl" + // InternalRos1Parser.g:1505:1: rule__Node__Group_4__2__Impl : ( ( rule__Node__SubscriberAssignment_4_2 )* ) ; + public final void rule__Node__Group_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1509:1: ( ( ( rule__Node__SubscriberAssignment_4_2 )* ) ) + // InternalRos1Parser.g:1510:1: ( ( rule__Node__SubscriberAssignment_4_2 )* ) + { + // InternalRos1Parser.g:1510:1: ( ( rule__Node__SubscriberAssignment_4_2 )* ) + // InternalRos1Parser.g:1511:2: ( rule__Node__SubscriberAssignment_4_2 )* + { + before(grammarAccess.getNodeAccess().getSubscriberAssignment_4_2()); + // InternalRos1Parser.g:1512:2: ( rule__Node__SubscriberAssignment_4_2 )* + loop14: + do { + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==RULE_ID||LA14_0==RULE_STRING) ) { + alt14=1; + } + + + switch (alt14) { + case 1 : + // InternalRos1Parser.g:1512:3: rule__Node__SubscriberAssignment_4_2 + { + pushFollow(FOLLOW_17); + rule__Node__SubscriberAssignment_4_2(); + + state._fsp--; + + + } + break; + + default : + break loop14; + } + } while (true); + + after(grammarAccess.getNodeAccess().getSubscriberAssignment_4_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__2__Impl" + + + // $ANTLR start "rule__Node__Group_4__3" + // InternalRos1Parser.g:1520:1: rule__Node__Group_4__3 : rule__Node__Group_4__3__Impl ; + public final void rule__Node__Group_4__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1524:1: ( rule__Node__Group_4__3__Impl ) + // InternalRos1Parser.g:1525:2: rule__Node__Group_4__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_4__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__3" + + + // $ANTLR start "rule__Node__Group_4__3__Impl" + // InternalRos1Parser.g:1531:1: rule__Node__Group_4__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_4__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1535:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1536:1: ( RULE_END ) + { + // InternalRos1Parser.g:1536:1: ( RULE_END ) + // InternalRos1Parser.g:1537:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_4__3__Impl" + + + // $ANTLR start "rule__Node__Group_5__0" + // InternalRos1Parser.g:1547:1: rule__Node__Group_5__0 : rule__Node__Group_5__0__Impl rule__Node__Group_5__1 ; + public final void rule__Node__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1551:1: ( rule__Node__Group_5__0__Impl rule__Node__Group_5__1 ) + // InternalRos1Parser.g:1552:2: rule__Node__Group_5__0__Impl rule__Node__Group_5__1 + { + pushFollow(FOLLOW_5); + rule__Node__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__0" + + + // $ANTLR start "rule__Node__Group_5__0__Impl" + // InternalRos1Parser.g:1559:1: rule__Node__Group_5__0__Impl : ( Parameters ) ; + public final void rule__Node__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1563:1: ( ( Parameters ) ) + // InternalRos1Parser.g:1564:1: ( Parameters ) + { + // InternalRos1Parser.g:1564:1: ( Parameters ) + // InternalRos1Parser.g:1565:2: Parameters + { + before(grammarAccess.getNodeAccess().getParametersKeyword_5_0()); + match(input,Parameters,FOLLOW_2); + after(grammarAccess.getNodeAccess().getParametersKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__0__Impl" + + + // $ANTLR start "rule__Node__Group_5__1" + // InternalRos1Parser.g:1574:1: rule__Node__Group_5__1 : rule__Node__Group_5__1__Impl rule__Node__Group_5__2 ; + public final void rule__Node__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1578:1: ( rule__Node__Group_5__1__Impl rule__Node__Group_5__2 ) + // InternalRos1Parser.g:1579:2: rule__Node__Group_5__1__Impl rule__Node__Group_5__2 + { + pushFollow(FOLLOW_16); + rule__Node__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__1" + + + // $ANTLR start "rule__Node__Group_5__1__Impl" + // InternalRos1Parser.g:1586:1: rule__Node__Group_5__1__Impl : ( RULE_BEGIN ) ; + public final void rule__Node__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1590:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1591:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1591:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1592:2: RULE_BEGIN + { + before(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__1__Impl" + + + // $ANTLR start "rule__Node__Group_5__2" + // InternalRos1Parser.g:1601:1: rule__Node__Group_5__2 : rule__Node__Group_5__2__Impl rule__Node__Group_5__3 ; + public final void rule__Node__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1605:1: ( rule__Node__Group_5__2__Impl rule__Node__Group_5__3 ) + // InternalRos1Parser.g:1606:2: rule__Node__Group_5__2__Impl rule__Node__Group_5__3 + { + pushFollow(FOLLOW_16); + rule__Node__Group_5__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Node__Group_5__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__2" + + + // $ANTLR start "rule__Node__Group_5__2__Impl" + // InternalRos1Parser.g:1613:1: rule__Node__Group_5__2__Impl : ( ( rule__Node__ParameterAssignment_5_2 )* ) ; + public final void rule__Node__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1617:1: ( ( ( rule__Node__ParameterAssignment_5_2 )* ) ) + // InternalRos1Parser.g:1618:1: ( ( rule__Node__ParameterAssignment_5_2 )* ) + { + // InternalRos1Parser.g:1618:1: ( ( rule__Node__ParameterAssignment_5_2 )* ) + // InternalRos1Parser.g:1619:2: ( rule__Node__ParameterAssignment_5_2 )* + { + before(grammarAccess.getNodeAccess().getParameterAssignment_5_2()); + // InternalRos1Parser.g:1620:2: ( rule__Node__ParameterAssignment_5_2 )* + loop15: + do { + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==RULE_ID||LA15_0==RULE_STRING) ) { + alt15=1; + } + + + switch (alt15) { + case 1 : + // InternalRos1Parser.g:1620:3: rule__Node__ParameterAssignment_5_2 + { + pushFollow(FOLLOW_17); + rule__Node__ParameterAssignment_5_2(); + + state._fsp--; + + + } + break; + + default : + break loop15; + } + } while (true); + + after(grammarAccess.getNodeAccess().getParameterAssignment_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__2__Impl" + + + // $ANTLR start "rule__Node__Group_5__3" + // InternalRos1Parser.g:1628:1: rule__Node__Group_5__3 : rule__Node__Group_5__3__Impl ; + public final void rule__Node__Group_5__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1632:1: ( rule__Node__Group_5__3__Impl ) + // InternalRos1Parser.g:1633:2: rule__Node__Group_5__3__Impl + { + pushFollow(FOLLOW_2); + rule__Node__Group_5__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__3" + + + // $ANTLR start "rule__Node__Group_5__3__Impl" + // InternalRos1Parser.g:1639:1: rule__Node__Group_5__3__Impl : ( RULE_END ) ; + public final void rule__Node__Group_5__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1643:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1644:1: ( RULE_END ) + { + // InternalRos1Parser.g:1644:1: ( RULE_END ) + // InternalRos1Parser.g:1645:2: RULE_END + { + before(grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__Group_5__3__Impl" + + + // $ANTLR start "rule__Publisher__Group__0" + // InternalRos1Parser.g:1655:1: rule__Publisher__Group__0 : rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ; + public final void rule__Publisher__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1659:1: ( rule__Publisher__Group__0__Impl rule__Publisher__Group__1 ) + // InternalRos1Parser.g:1660:2: rule__Publisher__Group__0__Impl rule__Publisher__Group__1 + { + pushFollow(FOLLOW_7); + rule__Publisher__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__0" + + + // $ANTLR start "rule__Publisher__Group__0__Impl" + // InternalRos1Parser.g:1667:1: rule__Publisher__Group__0__Impl : ( () ) ; + public final void rule__Publisher__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1671:1: ( ( () ) ) + // InternalRos1Parser.g:1672:1: ( () ) + { + // InternalRos1Parser.g:1672:1: ( () ) + // InternalRos1Parser.g:1673:2: () + { + before(grammarAccess.getPublisherAccess().getPublisherAction_0()); + // InternalRos1Parser.g:1674:2: () + // InternalRos1Parser.g:1674:3: + { + } + + after(grammarAccess.getPublisherAccess().getPublisherAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__0__Impl" + + + // $ANTLR start "rule__Publisher__Group__1" + // InternalRos1Parser.g:1682:1: rule__Publisher__Group__1 : rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ; + public final void rule__Publisher__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1686:1: ( rule__Publisher__Group__1__Impl rule__Publisher__Group__2 ) + // InternalRos1Parser.g:1687:2: rule__Publisher__Group__1__Impl rule__Publisher__Group__2 + { + pushFollow(FOLLOW_4); + rule__Publisher__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__1" + + + // $ANTLR start "rule__Publisher__Group__1__Impl" + // InternalRos1Parser.g:1694:1: rule__Publisher__Group__1__Impl : ( ( rule__Publisher__NameAssignment_1 ) ) ; + public final void rule__Publisher__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1698:1: ( ( ( rule__Publisher__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:1699:1: ( ( rule__Publisher__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:1699:1: ( ( rule__Publisher__NameAssignment_1 ) ) + // InternalRos1Parser.g:1700:2: ( rule__Publisher__NameAssignment_1 ) + { + before(grammarAccess.getPublisherAccess().getNameAssignment_1()); + // InternalRos1Parser.g:1701:2: ( rule__Publisher__NameAssignment_1 ) + // InternalRos1Parser.g:1701:3: rule__Publisher__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Publisher__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__1__Impl" + + + // $ANTLR start "rule__Publisher__Group__2" + // InternalRos1Parser.g:1709:1: rule__Publisher__Group__2 : rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ; + public final void rule__Publisher__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1713:1: ( rule__Publisher__Group__2__Impl rule__Publisher__Group__3 ) + // InternalRos1Parser.g:1714:2: rule__Publisher__Group__2__Impl rule__Publisher__Group__3 + { + pushFollow(FOLLOW_5); + rule__Publisher__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__2" + + + // $ANTLR start "rule__Publisher__Group__2__Impl" + // InternalRos1Parser.g:1721:1: rule__Publisher__Group__2__Impl : ( Colon ) ; + public final void rule__Publisher__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1725:1: ( ( Colon ) ) + // InternalRos1Parser.g:1726:1: ( Colon ) + { + // InternalRos1Parser.g:1726:1: ( Colon ) + // InternalRos1Parser.g:1727:2: Colon + { + before(grammarAccess.getPublisherAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__2__Impl" + + + // $ANTLR start "rule__Publisher__Group__3" + // InternalRos1Parser.g:1736:1: rule__Publisher__Group__3 : rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ; + public final void rule__Publisher__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1740:1: ( rule__Publisher__Group__3__Impl rule__Publisher__Group__4 ) + // InternalRos1Parser.g:1741:2: rule__Publisher__Group__3__Impl rule__Publisher__Group__4 + { + pushFollow(FOLLOW_18); + rule__Publisher__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__3" + + + // $ANTLR start "rule__Publisher__Group__3__Impl" + // InternalRos1Parser.g:1748:1: rule__Publisher__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Publisher__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1752:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1753:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1753:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1754:2: RULE_BEGIN + { + before(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__3__Impl" + + + // $ANTLR start "rule__Publisher__Group__4" + // InternalRos1Parser.g:1763:1: rule__Publisher__Group__4 : rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ; + public final void rule__Publisher__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1767:1: ( rule__Publisher__Group__4__Impl rule__Publisher__Group__5 ) + // InternalRos1Parser.g:1768:2: rule__Publisher__Group__4__Impl rule__Publisher__Group__5 + { + pushFollow(FOLLOW_7); + rule__Publisher__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__4" + + + // $ANTLR start "rule__Publisher__Group__4__Impl" + // InternalRos1Parser.g:1775:1: rule__Publisher__Group__4__Impl : ( Type ) ; + public final void rule__Publisher__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1779:1: ( ( Type ) ) + // InternalRos1Parser.g:1780:1: ( Type ) + { + // InternalRos1Parser.g:1780:1: ( Type ) + // InternalRos1Parser.g:1781:2: Type + { + before(grammarAccess.getPublisherAccess().getTypeKeyword_4()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__4__Impl" + + + // $ANTLR start "rule__Publisher__Group__5" + // InternalRos1Parser.g:1790:1: rule__Publisher__Group__5 : rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ; + public final void rule__Publisher__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1794:1: ( rule__Publisher__Group__5__Impl rule__Publisher__Group__6 ) + // InternalRos1Parser.g:1795:2: rule__Publisher__Group__5__Impl rule__Publisher__Group__6 + { + pushFollow(FOLLOW_19); + rule__Publisher__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Publisher__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__5" + + + // $ANTLR start "rule__Publisher__Group__5__Impl" + // InternalRos1Parser.g:1802:1: rule__Publisher__Group__5__Impl : ( ( rule__Publisher__MessageAssignment_5 ) ) ; + public final void rule__Publisher__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1806:1: ( ( ( rule__Publisher__MessageAssignment_5 ) ) ) + // InternalRos1Parser.g:1807:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + { + // InternalRos1Parser.g:1807:1: ( ( rule__Publisher__MessageAssignment_5 ) ) + // InternalRos1Parser.g:1808:2: ( rule__Publisher__MessageAssignment_5 ) + { + before(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + // InternalRos1Parser.g:1809:2: ( rule__Publisher__MessageAssignment_5 ) + // InternalRos1Parser.g:1809:3: rule__Publisher__MessageAssignment_5 + { + pushFollow(FOLLOW_2); + rule__Publisher__MessageAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getPublisherAccess().getMessageAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__5__Impl" + + + // $ANTLR start "rule__Publisher__Group__6" + // InternalRos1Parser.g:1817:1: rule__Publisher__Group__6 : rule__Publisher__Group__6__Impl ; + public final void rule__Publisher__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1821:1: ( rule__Publisher__Group__6__Impl ) + // InternalRos1Parser.g:1822:2: rule__Publisher__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__Publisher__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__6" + + + // $ANTLR start "rule__Publisher__Group__6__Impl" + // InternalRos1Parser.g:1828:1: rule__Publisher__Group__6__Impl : ( RULE_END ) ; + public final void rule__Publisher__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1832:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:1833:1: ( RULE_END ) + { + // InternalRos1Parser.g:1833:1: ( RULE_END ) + // InternalRos1Parser.g:1834:2: RULE_END + { + before(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getPublisherAccess().getENDTerminalRuleCall_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__Group__6__Impl" + + + // $ANTLR start "rule__Subscriber__Group__0" + // InternalRos1Parser.g:1844:1: rule__Subscriber__Group__0 : rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ; + public final void rule__Subscriber__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1848:1: ( rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 ) + // InternalRos1Parser.g:1849:2: rule__Subscriber__Group__0__Impl rule__Subscriber__Group__1 + { + pushFollow(FOLLOW_7); + rule__Subscriber__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__0" + + + // $ANTLR start "rule__Subscriber__Group__0__Impl" + // InternalRos1Parser.g:1856:1: rule__Subscriber__Group__0__Impl : ( () ) ; + public final void rule__Subscriber__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1860:1: ( ( () ) ) + // InternalRos1Parser.g:1861:1: ( () ) + { + // InternalRos1Parser.g:1861:1: ( () ) + // InternalRos1Parser.g:1862:2: () + { + before(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + // InternalRos1Parser.g:1863:2: () + // InternalRos1Parser.g:1863:3: + { + } + + after(grammarAccess.getSubscriberAccess().getSubscriberAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__0__Impl" + + + // $ANTLR start "rule__Subscriber__Group__1" + // InternalRos1Parser.g:1871:1: rule__Subscriber__Group__1 : rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ; + public final void rule__Subscriber__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1875:1: ( rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 ) + // InternalRos1Parser.g:1876:2: rule__Subscriber__Group__1__Impl rule__Subscriber__Group__2 + { + pushFollow(FOLLOW_4); + rule__Subscriber__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__1" + + + // $ANTLR start "rule__Subscriber__Group__1__Impl" + // InternalRos1Parser.g:1883:1: rule__Subscriber__Group__1__Impl : ( ( rule__Subscriber__NameAssignment_1 ) ) ; + public final void rule__Subscriber__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1887:1: ( ( ( rule__Subscriber__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:1888:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:1888:1: ( ( rule__Subscriber__NameAssignment_1 ) ) + // InternalRos1Parser.g:1889:2: ( rule__Subscriber__NameAssignment_1 ) + { + before(grammarAccess.getSubscriberAccess().getNameAssignment_1()); + // InternalRos1Parser.g:1890:2: ( rule__Subscriber__NameAssignment_1 ) + // InternalRos1Parser.g:1890:3: rule__Subscriber__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Subscriber__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__1__Impl" + + + // $ANTLR start "rule__Subscriber__Group__2" + // InternalRos1Parser.g:1898:1: rule__Subscriber__Group__2 : rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ; + public final void rule__Subscriber__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1902:1: ( rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 ) + // InternalRos1Parser.g:1903:2: rule__Subscriber__Group__2__Impl rule__Subscriber__Group__3 + { + pushFollow(FOLLOW_5); + rule__Subscriber__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__2" + + + // $ANTLR start "rule__Subscriber__Group__2__Impl" + // InternalRos1Parser.g:1910:1: rule__Subscriber__Group__2__Impl : ( Colon ) ; + public final void rule__Subscriber__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1914:1: ( ( Colon ) ) + // InternalRos1Parser.g:1915:1: ( Colon ) + { + // InternalRos1Parser.g:1915:1: ( Colon ) + // InternalRos1Parser.g:1916:2: Colon + { + before(grammarAccess.getSubscriberAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__2__Impl" + + + // $ANTLR start "rule__Subscriber__Group__3" + // InternalRos1Parser.g:1925:1: rule__Subscriber__Group__3 : rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ; + public final void rule__Subscriber__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1929:1: ( rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 ) + // InternalRos1Parser.g:1930:2: rule__Subscriber__Group__3__Impl rule__Subscriber__Group__4 + { + pushFollow(FOLLOW_18); + rule__Subscriber__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__3" + + + // $ANTLR start "rule__Subscriber__Group__3__Impl" + // InternalRos1Parser.g:1937:1: rule__Subscriber__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Subscriber__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1941:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:1942:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:1942:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:1943:2: RULE_BEGIN + { + before(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__3__Impl" + + + // $ANTLR start "rule__Subscriber__Group__4" + // InternalRos1Parser.g:1952:1: rule__Subscriber__Group__4 : rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ; + public final void rule__Subscriber__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1956:1: ( rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 ) + // InternalRos1Parser.g:1957:2: rule__Subscriber__Group__4__Impl rule__Subscriber__Group__5 + { + pushFollow(FOLLOW_7); + rule__Subscriber__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__4" + + + // $ANTLR start "rule__Subscriber__Group__4__Impl" + // InternalRos1Parser.g:1964:1: rule__Subscriber__Group__4__Impl : ( Type ) ; + public final void rule__Subscriber__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1968:1: ( ( Type ) ) + // InternalRos1Parser.g:1969:1: ( Type ) + { + // InternalRos1Parser.g:1969:1: ( Type ) + // InternalRos1Parser.g:1970:2: Type + { + before(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + match(input,Type,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__4__Impl" + + + // $ANTLR start "rule__Subscriber__Group__5" + // InternalRos1Parser.g:1979:1: rule__Subscriber__Group__5 : rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ; + public final void rule__Subscriber__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1983:1: ( rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 ) + // InternalRos1Parser.g:1984:2: rule__Subscriber__Group__5__Impl rule__Subscriber__Group__6 + { + pushFollow(FOLLOW_19); + rule__Subscriber__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Subscriber__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__5" + + + // $ANTLR start "rule__Subscriber__Group__5__Impl" + // InternalRos1Parser.g:1991:1: rule__Subscriber__Group__5__Impl : ( ( rule__Subscriber__MessageAssignment_5 ) ) ; + public final void rule__Subscriber__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:1995:1: ( ( ( rule__Subscriber__MessageAssignment_5 ) ) ) + // InternalRos1Parser.g:1996:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + { + // InternalRos1Parser.g:1996:1: ( ( rule__Subscriber__MessageAssignment_5 ) ) + // InternalRos1Parser.g:1997:2: ( rule__Subscriber__MessageAssignment_5 ) + { + before(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + // InternalRos1Parser.g:1998:2: ( rule__Subscriber__MessageAssignment_5 ) + // InternalRos1Parser.g:1998:3: rule__Subscriber__MessageAssignment_5 + { + pushFollow(FOLLOW_2); + rule__Subscriber__MessageAssignment_5(); + + state._fsp--; + + + } + + after(grammarAccess.getSubscriberAccess().getMessageAssignment_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__5__Impl" + + + // $ANTLR start "rule__Subscriber__Group__6" + // InternalRos1Parser.g:2006:1: rule__Subscriber__Group__6 : rule__Subscriber__Group__6__Impl ; + public final void rule__Subscriber__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2010:1: ( rule__Subscriber__Group__6__Impl ) + // InternalRos1Parser.g:2011:2: rule__Subscriber__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__Subscriber__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__6" + + + // $ANTLR start "rule__Subscriber__Group__6__Impl" + // InternalRos1Parser.g:2017:1: rule__Subscriber__Group__6__Impl : ( RULE_END ) ; + public final void rule__Subscriber__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2021:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:2022:1: ( RULE_END ) + { + // InternalRos1Parser.g:2022:1: ( RULE_END ) + // InternalRos1Parser.g:2023:2: RULE_END + { + before(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_6()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__Group__6__Impl" + + + // $ANTLR start "rule__Parameter__Group__0" + // InternalRos1Parser.g:2033:1: rule__Parameter__Group__0 : rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ; + public final void rule__Parameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2037:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) + // InternalRos1Parser.g:2038:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 + { + pushFollow(FOLLOW_7); + rule__Parameter__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__0" + + + // $ANTLR start "rule__Parameter__Group__0__Impl" + // InternalRos1Parser.g:2045:1: rule__Parameter__Group__0__Impl : ( () ) ; + public final void rule__Parameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2049:1: ( ( () ) ) + // InternalRos1Parser.g:2050:1: ( () ) + { + // InternalRos1Parser.g:2050:1: ( () ) + // InternalRos1Parser.g:2051:2: () + { + before(grammarAccess.getParameterAccess().getParameterAction_0()); + // InternalRos1Parser.g:2052:2: () + // InternalRos1Parser.g:2052:3: + { + } + + after(grammarAccess.getParameterAccess().getParameterAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__0__Impl" + + + // $ANTLR start "rule__Parameter__Group__1" + // InternalRos1Parser.g:2060:1: rule__Parameter__Group__1 : rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ; + public final void rule__Parameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2064:1: ( rule__Parameter__Group__1__Impl rule__Parameter__Group__2 ) + // InternalRos1Parser.g:2065:2: rule__Parameter__Group__1__Impl rule__Parameter__Group__2 + { + pushFollow(FOLLOW_4); + rule__Parameter__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__1" + + + // $ANTLR start "rule__Parameter__Group__1__Impl" + // InternalRos1Parser.g:2072:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; + public final void rule__Parameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2076:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) + // InternalRos1Parser.g:2077:1: ( ( rule__Parameter__NameAssignment_1 ) ) + { + // InternalRos1Parser.g:2077:1: ( ( rule__Parameter__NameAssignment_1 ) ) + // InternalRos1Parser.g:2078:2: ( rule__Parameter__NameAssignment_1 ) + { + before(grammarAccess.getParameterAccess().getNameAssignment_1()); + // InternalRos1Parser.g:2079:2: ( rule__Parameter__NameAssignment_1 ) + // InternalRos1Parser.g:2079:3: rule__Parameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__1__Impl" + + + // $ANTLR start "rule__Parameter__Group__2" + // InternalRos1Parser.g:2087:1: rule__Parameter__Group__2 : rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ; + public final void rule__Parameter__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2091:1: ( rule__Parameter__Group__2__Impl rule__Parameter__Group__3 ) + // InternalRos1Parser.g:2092:2: rule__Parameter__Group__2__Impl rule__Parameter__Group__3 + { + pushFollow(FOLLOW_5); + rule__Parameter__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__2" + + + // $ANTLR start "rule__Parameter__Group__2__Impl" + // InternalRos1Parser.g:2099:1: rule__Parameter__Group__2__Impl : ( Colon ) ; + public final void rule__Parameter__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2103:1: ( ( Colon ) ) + // InternalRos1Parser.g:2104:1: ( Colon ) + { + // InternalRos1Parser.g:2104:1: ( Colon ) + // InternalRos1Parser.g:2105:2: Colon + { + before(grammarAccess.getParameterAccess().getColonKeyword_2()); + match(input,Colon,FOLLOW_2); + after(grammarAccess.getParameterAccess().getColonKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__2__Impl" + + + // $ANTLR start "rule__Parameter__Group__3" + // InternalRos1Parser.g:2114:1: rule__Parameter__Group__3 : rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ; + public final void rule__Parameter__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2118:1: ( rule__Parameter__Group__3__Impl rule__Parameter__Group__4 ) + // InternalRos1Parser.g:2119:2: rule__Parameter__Group__3__Impl rule__Parameter__Group__4 + { + pushFollow(FOLLOW_19); + rule__Parameter__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__3" + + + // $ANTLR start "rule__Parameter__Group__3__Impl" + // InternalRos1Parser.g:2126:1: rule__Parameter__Group__3__Impl : ( RULE_BEGIN ) ; + public final void rule__Parameter__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2130:1: ( ( RULE_BEGIN ) ) + // InternalRos1Parser.g:2131:1: ( RULE_BEGIN ) + { + // InternalRos1Parser.g:2131:1: ( RULE_BEGIN ) + // InternalRos1Parser.g:2132:2: RULE_BEGIN + { + before(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + match(input,RULE_BEGIN,FOLLOW_2); + after(grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__3__Impl" + + + // $ANTLR start "rule__Parameter__Group__4" + // InternalRos1Parser.g:2141:1: rule__Parameter__Group__4 : rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ; + public final void rule__Parameter__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2145:1: ( rule__Parameter__Group__4__Impl rule__Parameter__Group__5 ) + // InternalRos1Parser.g:2146:2: rule__Parameter__Group__4__Impl rule__Parameter__Group__5 + { + pushFollow(FOLLOW_20); + rule__Parameter__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__4" + + + // $ANTLR start "rule__Parameter__Group__4__Impl" + // InternalRos1Parser.g:2153:1: rule__Parameter__Group__4__Impl : ( RULE_END ) ; + public final void rule__Parameter__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2157:1: ( ( RULE_END ) ) + // InternalRos1Parser.g:2158:1: ( RULE_END ) + { + // InternalRos1Parser.g:2158:1: ( RULE_END ) + // InternalRos1Parser.g:2159:2: RULE_END + { + before(grammarAccess.getParameterAccess().getENDTerminalRuleCall_4()); + match(input,RULE_END,FOLLOW_2); + after(grammarAccess.getParameterAccess().getENDTerminalRuleCall_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__4__Impl" + + + // $ANTLR start "rule__Parameter__Group__5" + // InternalRos1Parser.g:2168:1: rule__Parameter__Group__5 : rule__Parameter__Group__5__Impl ; + public final void rule__Parameter__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2172:1: ( rule__Parameter__Group__5__Impl ) + // InternalRos1Parser.g:2173:2: rule__Parameter__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__5" + + + // $ANTLR start "rule__Parameter__Group__5__Impl" + // InternalRos1Parser.g:2179:1: rule__Parameter__Group__5__Impl : ( RightCurlyBracket ) ; + public final void rule__Parameter__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2183:1: ( ( RightCurlyBracket ) ) + // InternalRos1Parser.g:2184:1: ( RightCurlyBracket ) + { + // InternalRos1Parser.g:2184:1: ( RightCurlyBracket ) + // InternalRos1Parser.g:2185:2: RightCurlyBracket + { + before(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_5()); + match(input,RightCurlyBracket,FOLLOW_2); + after(grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__5__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__0" + // InternalRos1Parser.g:2195:1: rule__ExternalDependency__Group__0 : rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ; + public final void rule__ExternalDependency__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2199:1: ( rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 ) + // InternalRos1Parser.g:2200:2: rule__ExternalDependency__Group__0__Impl rule__ExternalDependency__Group__1 + { + pushFollow(FOLLOW_11); + rule__ExternalDependency__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ExternalDependency__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__0" + + + // $ANTLR start "rule__ExternalDependency__Group__0__Impl" + // InternalRos1Parser.g:2207:1: rule__ExternalDependency__Group__0__Impl : ( () ) ; + public final void rule__ExternalDependency__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2211:1: ( ( () ) ) + // InternalRos1Parser.g:2212:1: ( () ) + { + // InternalRos1Parser.g:2212:1: ( () ) + // InternalRos1Parser.g:2213:2: () + { + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + // InternalRos1Parser.g:2214:2: () + // InternalRos1Parser.g:2214:3: + { + } + + after(grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__0__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__1" + // InternalRos1Parser.g:2222:1: rule__ExternalDependency__Group__1 : rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ; + public final void rule__ExternalDependency__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2226:1: ( rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 ) + // InternalRos1Parser.g:2227:2: rule__ExternalDependency__Group__1__Impl rule__ExternalDependency__Group__2 + { + pushFollow(FOLLOW_7); + rule__ExternalDependency__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ExternalDependency__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__1" + + + // $ANTLR start "rule__ExternalDependency__Group__1__Impl" + // InternalRos1Parser.g:2234:1: rule__ExternalDependency__Group__1__Impl : ( ExternalDependency ) ; + public final void rule__ExternalDependency__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2238:1: ( ( ExternalDependency ) ) + // InternalRos1Parser.g:2239:1: ( ExternalDependency ) + { + // InternalRos1Parser.g:2239:1: ( ExternalDependency ) + // InternalRos1Parser.g:2240:2: ExternalDependency + { + before(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + match(input,ExternalDependency,FOLLOW_2); + after(grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__1__Impl" + + + // $ANTLR start "rule__ExternalDependency__Group__2" + // InternalRos1Parser.g:2249:1: rule__ExternalDependency__Group__2 : rule__ExternalDependency__Group__2__Impl ; + public final void rule__ExternalDependency__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2253:1: ( rule__ExternalDependency__Group__2__Impl ) + // InternalRos1Parser.g:2254:2: rule__ExternalDependency__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ExternalDependency__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__2" + + + // $ANTLR start "rule__ExternalDependency__Group__2__Impl" + // InternalRos1Parser.g:2260:1: rule__ExternalDependency__Group__2__Impl : ( ( rule__ExternalDependency__NameAssignment_2 ) ) ; + public final void rule__ExternalDependency__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2264:1: ( ( ( rule__ExternalDependency__NameAssignment_2 ) ) ) + // InternalRos1Parser.g:2265:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + { + // InternalRos1Parser.g:2265:1: ( ( rule__ExternalDependency__NameAssignment_2 ) ) + // InternalRos1Parser.g:2266:2: ( rule__ExternalDependency__NameAssignment_2 ) + { + before(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); + // InternalRos1Parser.g:2267:2: ( rule__ExternalDependency__NameAssignment_2 ) + // InternalRos1Parser.g:2267:3: rule__ExternalDependency__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ExternalDependency__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getExternalDependencyAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__Group__2__Impl" + + + // $ANTLR start "rule__CatkinPackage__NameAssignment_1" + // InternalRos1Parser.g:2276:1: rule__CatkinPackage__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__CatkinPackage__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2280:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:2281:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:2281:2: ( ruleRosNames ) + // InternalRos1Parser.g:2282:3: ruleRosNames + { + before(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__NameAssignment_1" + + + // $ANTLR start "rule__CatkinPackage__FromGitRepoAssignment_4_1" + // InternalRos1Parser.g:2291:1: rule__CatkinPackage__FromGitRepoAssignment_4_1 : ( ruleEString ) ; + public final void rule__CatkinPackage__FromGitRepoAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2295:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:2296:2: ( ruleEString ) + { + // InternalRos1Parser.g:2296:2: ( ruleEString ) + // InternalRos1Parser.g:2297:3: ruleEString + { + before(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__FromGitRepoAssignment_4_1" + + + // $ANTLR start "rule__CatkinPackage__ArtifactAssignment_5_2" + // InternalRos1Parser.g:2306:1: rule__CatkinPackage__ArtifactAssignment_5_2 : ( ruleArtifact ) ; + public final void rule__CatkinPackage__ArtifactAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2310:1: ( ( ruleArtifact ) ) + // InternalRos1Parser.g:2311:2: ( ruleArtifact ) + { + // InternalRos1Parser.g:2311:2: ( ruleArtifact ) + // InternalRos1Parser.g:2312:3: ruleArtifact + { + before(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + ruleArtifact(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__ArtifactAssignment_5_2" + + + // $ANTLR start "rule__CatkinPackage__DependencyAssignment_6_2" + // InternalRos1Parser.g:2321:1: rule__CatkinPackage__DependencyAssignment_6_2 : ( ruleDependency ) ; + public final void rule__CatkinPackage__DependencyAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2325:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:2326:2: ( ruleDependency ) + { + // InternalRos1Parser.g:2326:2: ( ruleDependency ) + // InternalRos1Parser.g:2327:3: ruleDependency + { + before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__DependencyAssignment_6_2" + + + // $ANTLR start "rule__CatkinPackage__DependencyAssignment_6_3_1" + // InternalRos1Parser.g:2336:1: rule__CatkinPackage__DependencyAssignment_6_3_1 : ( ruleDependency ) ; + public final void rule__CatkinPackage__DependencyAssignment_6_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2340:1: ( ( ruleDependency ) ) + // InternalRos1Parser.g:2341:2: ( ruleDependency ) + { + // InternalRos1Parser.g:2341:2: ( ruleDependency ) + // InternalRos1Parser.g:2342:3: ruleDependency + { + before(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + pushFollow(FOLLOW_2); + ruleDependency(); + + state._fsp--; + + after(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CatkinPackage__DependencyAssignment_6_3_1" + + + // $ANTLR start "rule__Artifact__NameAssignment_1" + // InternalRos1Parser.g:2351:1: rule__Artifact__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Artifact__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2355:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:2356:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:2356:2: ( ruleRosNames ) + // InternalRos1Parser.g:2357:3: ruleRosNames + { + before(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__NameAssignment_1" + + + // $ANTLR start "rule__Artifact__NodeAssignment_4" + // InternalRos1Parser.g:2366:1: rule__Artifact__NodeAssignment_4 : ( ruleNode ) ; + public final void rule__Artifact__NodeAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2370:1: ( ( ruleNode ) ) + // InternalRos1Parser.g:2371:2: ( ruleNode ) + { + // InternalRos1Parser.g:2371:2: ( ruleNode ) + // InternalRos1Parser.g:2372:3: ruleNode + { + before(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + pushFollow(FOLLOW_2); + ruleNode(); + + state._fsp--; + + after(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Artifact__NodeAssignment_4" + + + // $ANTLR start "rule__Node__NameAssignment_1" + // InternalRos1Parser.g:2381:1: rule__Node__NameAssignment_1 : ( ruleRosNames ) ; + public final void rule__Node__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2385:1: ( ( ruleRosNames ) ) + // InternalRos1Parser.g:2386:2: ( ruleRosNames ) + { + // InternalRos1Parser.g:2386:2: ( ruleRosNames ) + // InternalRos1Parser.g:2387:3: ruleRosNames + { + before(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleRosNames(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__NameAssignment_1" + + + // $ANTLR start "rule__Node__PublisherAssignment_3_2" + // InternalRos1Parser.g:2396:1: rule__Node__PublisherAssignment_3_2 : ( rulePublisher ) ; + public final void rule__Node__PublisherAssignment_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2400:1: ( ( rulePublisher ) ) + // InternalRos1Parser.g:2401:2: ( rulePublisher ) + { + // InternalRos1Parser.g:2401:2: ( rulePublisher ) + // InternalRos1Parser.g:2402:3: rulePublisher + { + before(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_2_0()); + pushFollow(FOLLOW_2); + rulePublisher(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__PublisherAssignment_3_2" + + + // $ANTLR start "rule__Node__SubscriberAssignment_4_2" + // InternalRos1Parser.g:2411:1: rule__Node__SubscriberAssignment_4_2 : ( ruleSubscriber ) ; + public final void rule__Node__SubscriberAssignment_4_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2415:1: ( ( ruleSubscriber ) ) + // InternalRos1Parser.g:2416:2: ( ruleSubscriber ) + { + // InternalRos1Parser.g:2416:2: ( ruleSubscriber ) + // InternalRos1Parser.g:2417:3: ruleSubscriber + { + before(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_4_2_0()); + pushFollow(FOLLOW_2); + ruleSubscriber(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_4_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__SubscriberAssignment_4_2" + + + // $ANTLR start "rule__Node__ParameterAssignment_5_2" + // InternalRos1Parser.g:2426:1: rule__Node__ParameterAssignment_5_2 : ( ruleParameter ) ; + public final void rule__Node__ParameterAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2430:1: ( ( ruleParameter ) ) + // InternalRos1Parser.g:2431:2: ( ruleParameter ) + { + // InternalRos1Parser.g:2431:2: ( ruleParameter ) + // InternalRos1Parser.g:2432:3: ruleParameter + { + before(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_5_2_0()); + pushFollow(FOLLOW_2); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Node__ParameterAssignment_5_2" + + + // $ANTLR start "rule__Publisher__NameAssignment_1" + // InternalRos1Parser.g:2441:1: rule__Publisher__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Publisher__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2445:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:2446:2: ( ruleEString ) + { + // InternalRos1Parser.g:2446:2: ( ruleEString ) + // InternalRos1Parser.g:2447:3: ruleEString + { + before(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__NameAssignment_1" + + + // $ANTLR start "rule__Publisher__MessageAssignment_5" + // InternalRos1Parser.g:2456:1: rule__Publisher__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Publisher__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2460:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:2461:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:2461:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:2462:3: ( ruleEString ) + { + before(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos1Parser.g:2463:3: ( ruleEString ) + // InternalRos1Parser.g:2464:4: ruleEString + { + before(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Publisher__MessageAssignment_5" + + + // $ANTLR start "rule__Subscriber__NameAssignment_1" + // InternalRos1Parser.g:2475:1: rule__Subscriber__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Subscriber__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2479:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:2480:2: ( ruleEString ) + { + // InternalRos1Parser.g:2480:2: ( ruleEString ) + // InternalRos1Parser.g:2481:3: ruleEString + { + before(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__NameAssignment_1" + + + // $ANTLR start "rule__Subscriber__MessageAssignment_5" + // InternalRos1Parser.g:2490:1: rule__Subscriber__MessageAssignment_5 : ( ( ruleEString ) ) ; + public final void rule__Subscriber__MessageAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2494:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:2495:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:2495:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:2496:3: ( ruleEString ) + { + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + // InternalRos1Parser.g:2497:3: ( ruleEString ) + // InternalRos1Parser.g:2498:4: ruleEString + { + before(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1()); + + } + + after(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Subscriber__MessageAssignment_5" + + + // $ANTLR start "rule__Parameter__NameAssignment_1" + // InternalRos1Parser.g:2509:1: rule__Parameter__NameAssignment_1 : ( ruleEString ) ; + public final void rule__Parameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2513:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:2514:2: ( ruleEString ) + { + // InternalRos1Parser.g:2514:2: ( ruleEString ) + // InternalRos1Parser.g:2515:3: ruleEString + { + before(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__NameAssignment_1" + + + // $ANTLR start "rule__PackageDependency__PackageAssignment" + // InternalRos1Parser.g:2524:1: rule__PackageDependency__PackageAssignment : ( ( ruleEString ) ) ; + public final void rule__PackageDependency__PackageAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2528:1: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:2529:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:2529:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:2530:3: ( ruleEString ) + { + before(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + // InternalRos1Parser.g:2531:3: ( ruleEString ) + // InternalRos1Parser.g:2532:4: ruleEString + { + before(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1()); + + } + + after(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PackageDependency__PackageAssignment" + + + // $ANTLR start "rule__ExternalDependency__NameAssignment_2" + // InternalRos1Parser.g:2543:1: rule__ExternalDependency__NameAssignment_2 : ( ruleEString ) ; + public final void rule__ExternalDependency__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalRos1Parser.g:2547:1: ( ( ruleEString ) ) + // InternalRos1Parser.g:2548:2: ( ruleEString ) + { + // InternalRos1Parser.g:2548:2: ( ruleEString ) + // InternalRos1Parser.g:2549:3: ruleEString + { + before(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + after(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExternalDependency__NameAssignment_2" + + // Delegated rules + + + + + 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[]{0x0000000000C02000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000080000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000100460L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000001400000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000D02000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000C02002L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000001400010L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000024000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000004002L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000100800L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000100380L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000001500000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000001400002L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000001000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000100000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000040000L}); + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.tokens b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.tokens new file mode 100644 index 000000000..aec474468 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/internal/InternalRos1Parser.tokens @@ -0,0 +1,26 @@ +','=14 +':'=15 +'ExternalDependency'=4 +'['=16 +']'=17 +'artifacts:'=10 +'dependencies:'=5 +'fromGitRepo:'=6 +'node'=13 +'node:'=11 +'parameters:'=8 +'publishers:'=9 +'subscribers:'=7 +'type:'=12 +'}'=18 +RULE_ANY_OTHER=29 +RULE_BEGIN=19 +RULE_END=20 +RULE_ID=22 +RULE_INT=26 +RULE_ML_COMMENT=27 +RULE_ROS_CONVENTION_A=23 +RULE_ROS_CONVENTION_PARAM=25 +RULE_SL_COMMENT=21 +RULE_STRING=24 +RULE_WS=28 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.g b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.g new file mode 100644 index 000000000..44a537057 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.g @@ -0,0 +1,64 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRos1Lexer; + +@header { +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr.lexer; + +// 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.ide.editor.contentassist.antlr.internal.Lexer; +} + +ExternalDependency : 'ExternalDependency'; + +Dependencies : 'dependencies:'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +Node_1 : 'node:'; + +Type : 'type:'; + +Node : 'node'; + +Comma : ','; + +Colon : ':'; + +LeftSquareBracket : '['; + +RightSquareBracket : ']'; + +RightCurlyBracket : '}'; + +fragment RULE_BEGIN : ; + +fragment RULE_END : ; + +RULE_SL_COMMENT : '#' ~(('\n'|'\r'))*; + +RULE_ROS_CONVENTION_A : ('/' RULE_ID|RULE_ID '/')*; + +RULE_ROS_CONVENTION_PARAM : ('/' RULE_STRING|RULE_STRING '/'|'~' RULE_STRING)*; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +RULE_INT : ('0'..'9')+; + +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.java new file mode 100644 index 000000000..dcbfb4076 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.java @@ -0,0 +1,1508 @@ +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr.lexer; + +// 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.ide.editor.contentassist.antlr.internal.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalRos1Lexer extends Lexer { + public static final int RULE_END=20; + public static final int RULE_BEGIN=19; + public static final int Node=13; + public static final int RULE_STRING=24; + public static final int RULE_SL_COMMENT=21; + public static final int Comma=14; + public static final int RULE_ROS_CONVENTION_A=23; + public static final int Publishers=9; + public static final int RULE_ROS_CONVENTION_PARAM=25; + public static final int Dependencies=5; + public static final int Colon=15; + public static final int RightCurlyBracket=18; + public static final int EOF=-1; + public static final int RightSquareBracket=17; + public static final int FromGitRepo=6; + public static final int ExternalDependency=4; + public static final int Parameters=8; + public static final int RULE_ID=22; + public static final int RULE_WS=28; + public static final int RULE_ANY_OTHER=29; + public static final int Artifacts=10; + public static final int Node_1=11; + public static final int Type=12; + public static final int RULE_INT=26; + public static final int RULE_ML_COMMENT=27; + public static final int LeftSquareBracket=16; + public static final int Subscribers=7; + + // delegates + // delegators + + public InternalRos1Lexer() {;} + public InternalRos1Lexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos1Lexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRos1Lexer.g"; } + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:14:20: ( 'ExternalDependency' ) + // InternalRos1Lexer.g:14:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:16:14: ( 'dependencies:' ) + // InternalRos1Lexer.g:16:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:18:13: ( 'fromGitRepo:' ) + // InternalRos1Lexer.g:18:15: 'fromGitRepo:' + { + match("fromGitRepo:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FromGitRepo" + + // $ANTLR start "Subscribers" + public final void mSubscribers() throws RecognitionException { + try { + int _type = Subscribers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:20:13: ( 'subscribers:' ) + // InternalRos1Lexer.g:20:15: 'subscribers:' + { + match("subscribers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Subscribers" + + // $ANTLR start "Parameters" + public final void mParameters() throws RecognitionException { + try { + int _type = Parameters; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:22:12: ( 'parameters:' ) + // InternalRos1Lexer.g:22:14: 'parameters:' + { + match("parameters:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Parameters" + + // $ANTLR start "Publishers" + public final void mPublishers() throws RecognitionException { + try { + int _type = Publishers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:24:12: ( 'publishers:' ) + // InternalRos1Lexer.g:24:14: 'publishers:' + { + match("publishers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Publishers" + + // $ANTLR start "Artifacts" + public final void mArtifacts() throws RecognitionException { + try { + int _type = Artifacts; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:26:11: ( 'artifacts:' ) + // InternalRos1Lexer.g:26:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:28:8: ( 'node:' ) + // InternalRos1Lexer.g:28:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:30:6: ( 'type:' ) + // InternalRos1Lexer.g:30:8: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:32:6: ( 'node' ) + // InternalRos1Lexer.g:32:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:34:7: ( ',' ) + // InternalRos1Lexer.g:34:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Comma" + + // $ANTLR start "Colon" + public final void mColon() throws RecognitionException { + try { + int _type = Colon; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:36:7: ( ':' ) + // InternalRos1Lexer.g:36:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Colon" + + // $ANTLR start "LeftSquareBracket" + public final void mLeftSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:38:19: ( '[' ) + // InternalRos1Lexer.g:38:21: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracket" + + // $ANTLR start "RightSquareBracket" + public final void mRightSquareBracket() throws RecognitionException { + try { + int _type = RightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:40:20: ( ']' ) + // InternalRos1Lexer.g:40:22: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightSquareBracket" + + // $ANTLR start "RightCurlyBracket" + public final void mRightCurlyBracket() throws RecognitionException { + try { + int _type = RightCurlyBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:42:19: ( '}' ) + // InternalRos1Lexer.g:42:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRos1Lexer.g:44:21: () + // InternalRos1Lexer.g:44:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos1Lexer.g:46:19: () + // InternalRos1Lexer.g:46:21: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_END" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:48:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos1Lexer.g:48:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos1Lexer.g:48:23: (~ ( ( '\\n' | '\\r' ) ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalRos1Lexer.g:48:23: ~ ( ( '\\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 loop1; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_ROS_CONVENTION_A" + public final void mRULE_ROS_CONVENTION_A() throws RecognitionException { + try { + int _type = RULE_ROS_CONVENTION_A; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:50:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos1Lexer.g:50:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos1Lexer.g:50:25: ( '/' RULE_ID | RULE_ID '/' )* + loop2: + do { + int alt2=3; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='/') ) { + alt2=1; + } + else if ( ((LA2_0>='A' && LA2_0<='Z')||(LA2_0>='^' && LA2_0<='_')||(LA2_0>='a' && LA2_0<='z')) ) { + alt2=2; + } + + + switch (alt2) { + case 1 : + // InternalRos1Lexer.g:50:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:50:38: RULE_ID '/' + { + mRULE_ID(); + match('/'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ROS_CONVENTION_A" + + // $ANTLR start "RULE_ROS_CONVENTION_PARAM" + public final void mRULE_ROS_CONVENTION_PARAM() throws RecognitionException { + try { + int _type = RULE_ROS_CONVENTION_PARAM; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:52:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos1Lexer.g:52:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos1Lexer.g:52:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + loop3: + do { + int alt3=4; + switch ( input.LA(1) ) { + case '/': + { + alt3=1; + } + break; + case '\"': + case '\'': + { + alt3=2; + } + break; + case '~': + { + alt3=3; + } + break; + + } + + switch (alt3) { + case 1 : + // InternalRos1Lexer.g:52:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos1Lexer.g:52:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos1Lexer.g:52:62: '~' RULE_STRING + { + match('~'); + mRULE_STRING(); + + } + break; + + default : + break loop3; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ROS_CONVENTION_PARAM" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:54:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos1Lexer.g:54:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos1Lexer.g:54:11: ( '^' )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='^') ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalRos1Lexer.g:54:11: '^' + { + match('^'); + + } + break; + + } + + if ( (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;} + + // InternalRos1Lexer.g:54:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='9')||(LA5_0>='A' && LA5_0<='Z')||LA5_0=='_'||(LA5_0>='a' && LA5_0<='z')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos1Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop5; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:56:10: ( ( '0' .. '9' )+ ) + // InternalRos1Lexer.g:56:12: ( '0' .. '9' )+ + { + // InternalRos1Lexer.g:56:12: ( '0' .. '9' )+ + int cnt6=0; + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( ((LA6_0>='0' && LA6_0<='9')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalRos1Lexer.g:56:13: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt6 >= 1 ) break loop6; + EarlyExitException eee = + new EarlyExitException(6, input); + throw eee; + } + cnt6++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:58:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos1Lexer.g:58:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos1Lexer.g:58:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='\"') ) { + alt9=1; + } + else if ( (LA9_0=='\'') ) { + alt9=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // InternalRos1Lexer.g:58:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos1Lexer.g:58:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop7: + do { + int alt7=3; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='\\') ) { + alt7=1; + } + else if ( ((LA7_0>='\u0000' && LA7_0<='!')||(LA7_0>='#' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { + alt7=2; + } + + + switch (alt7) { + case 1 : + // InternalRos1Lexer.g:58:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:58: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 loop7; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos1Lexer.g:58:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos1Lexer.g:58:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop8: + do { + int alt8=3; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='\\') ) { + alt8=1; + } + else if ( ((LA8_0>='\u0000' && LA8_0<='&')||(LA8_0>='(' && LA8_0<='[')||(LA8_0>=']' && LA8_0<='\uFFFF')) ) { + alt8=2; + } + + + switch (alt8) { + case 1 : + // InternalRos1Lexer.g:58:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:58:61: ~ ( ( '\\\\' | '\\'' ) ) + { + 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 loop8; + } + } while (true); + + match('\''); + + } + 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; + // InternalRos1Lexer.g:60:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos1Lexer.g:60:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos1Lexer.g:60:24: ( options {greedy=false; } : . )* + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='*') ) { + int LA10_1 = input.LA(2); + + if ( (LA10_1=='/') ) { + alt10=2; + } + else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { + alt10=1; + } + + + } + else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { + alt10=1; + } + + + switch (alt10) { + case 1 : + // InternalRos1Lexer.g:60:52: . + { + matchAny(); + + } + break; + + default : + break loop10; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:62:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos1Lexer.g:62:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos1Lexer.g:62:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt11=0; + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // InternalRos1Lexer.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 ( cnt11 >= 1 ) break loop11; + EarlyExitException eee = + new EarlyExitException(11, input); + throw eee; + } + cnt11++; + } 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; + // InternalRos1Lexer.g:64:16: ( . ) + // InternalRos1Lexer.g:64:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos1Lexer.g:1:8: ( ExternalDependency | Dependencies | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | Node_1 | Type | Node | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt12=24; + alt12 = dfa12.predict(input); + switch (alt12) { + case 1 : + // InternalRos1Lexer.g:1:10: ExternalDependency + { + mExternalDependency(); + + } + break; + case 2 : + // InternalRos1Lexer.g:1:29: Dependencies + { + mDependencies(); + + } + break; + case 3 : + // InternalRos1Lexer.g:1:42: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 4 : + // InternalRos1Lexer.g:1:54: Subscribers + { + mSubscribers(); + + } + break; + case 5 : + // InternalRos1Lexer.g:1:66: Parameters + { + mParameters(); + + } + break; + case 6 : + // InternalRos1Lexer.g:1:77: Publishers + { + mPublishers(); + + } + break; + case 7 : + // InternalRos1Lexer.g:1:88: Artifacts + { + mArtifacts(); + + } + break; + case 8 : + // InternalRos1Lexer.g:1:98: Node_1 + { + mNode_1(); + + } + break; + case 9 : + // InternalRos1Lexer.g:1:105: Type + { + mType(); + + } + break; + case 10 : + // InternalRos1Lexer.g:1:110: Node + { + mNode(); + + } + break; + case 11 : + // InternalRos1Lexer.g:1:115: Comma + { + mComma(); + + } + break; + case 12 : + // InternalRos1Lexer.g:1:121: Colon + { + mColon(); + + } + break; + case 13 : + // InternalRos1Lexer.g:1:127: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 14 : + // InternalRos1Lexer.g:1:145: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 15 : + // InternalRos1Lexer.g:1:164: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 16 : + // InternalRos1Lexer.g:1:182: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 17 : + // InternalRos1Lexer.g:1:198: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 18 : + // InternalRos1Lexer.g:1:220: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 19 : + // InternalRos1Lexer.g:1:246: RULE_ID + { + mRULE_ID(); + + } + break; + case 20 : + // InternalRos1Lexer.g:1:254: RULE_INT + { + mRULE_INT(); + + } + break; + case 21 : + // InternalRos1Lexer.g:1:263: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 22 : + // InternalRos1Lexer.g:1:275: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 23 : + // InternalRos1Lexer.g:1:291: RULE_WS + { + mRULE_WS(); + + } + break; + case 24 : + // InternalRos1Lexer.g:1:299: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA12 dfa12 = new DFA12(this); + static final String DFA12_eotS = + "\1\22\10\32\6\uffff\2\30\1\32\1\uffff\3\30\3\uffff\1\32\1\uffff\11\32\10\uffff\1\32\2\uffff\1\77\2\uffff\1\77\2\uffff\11\32\3\uffff\7\32\1\122\10\32\3\uffff\42\32\1\uffff\4\32\2\uffff\2\32\2\uffff\1\32\1\uffff\4\32\1\u0088\1\uffff"; + static final String DFA12_eofS = + "\u0089\uffff"; + static final String DFA12_minS = + "\1\0\10\57\6\uffff\1\42\1\101\1\57\1\uffff\2\0\1\42\3\uffff\1\57\1\uffff\11\57\10\uffff\1\57\2\0\1\57\2\0\1\57\2\uffff\11\57\1\0\1\uffff\1\0\20\57\3\uffff\42\57\1\uffff\4\57\2\uffff\2\57\2\uffff\1\57\1\uffff\5\57\1\uffff"; + static final String DFA12_maxS = + "\1\uffff\10\172\6\uffff\3\172\1\uffff\2\uffff\1\47\3\uffff\1\172\1\uffff\11\172\10\uffff\1\172\2\uffff\1\57\2\uffff\1\57\2\uffff\11\172\1\uffff\1\uffff\1\uffff\20\172\3\uffff\42\172\1\uffff\4\172\2\uffff\2\172\2\uffff\1\172\1\uffff\5\172\1\uffff"; + static final String DFA12_acceptS = + "\11\uffff\1\13\1\14\1\15\1\16\1\17\1\20\3\uffff\1\21\3\uffff\1\24\1\27\1\30\1\uffff\1\23\11\uffff\1\13\1\14\1\15\1\16\1\17\1\20\1\26\1\22\7\uffff\1\24\1\27\12\uffff\1\25\21\uffff\1\10\1\12\1\11\42\uffff\1\7\4\uffff\1\5\1\6\2\uffff\1\3\1\4\1\uffff\1\2\5\uffff\1\1"; + static final String DFA12_specialS = + "\1\10\22\uffff\1\6\1\7\30\uffff\1\4\1\1\1\uffff\1\5\1\3\14\uffff\1\0\1\uffff\1\2\110\uffff}>"; + static final String[] DFA12_transitionS = { + "\11\30\2\27\2\30\1\27\22\30\1\27\1\30\1\23\1\16\3\30\1\24\4\30\1\11\2\30\1\17\12\26\1\12\6\30\4\21\1\1\25\21\1\13\1\30\1\14\1\20\1\21\1\30\1\6\2\21\1\2\1\21\1\3\7\21\1\7\1\21\1\5\2\21\1\4\1\10\6\21\2\30\1\15\1\25\uff81\30", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\27\33\1\31\2\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\34\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\35\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\24\33\1\36\5\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\37\23\33\1\40\5\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\41\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\42\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\30\33\1\43\1\33", + "", + "", + "", + "", + "", + "", + "\1\53\4\uffff\1\53\2\uffff\1\52\26\uffff\32\22\3\uffff\2\22\1\uffff\32\22", + "\32\54\4\uffff\1\54\1\uffff\32\54", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "\42\56\1\57\71\56\1\55\uffa3\56", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\53\4\uffff\1\53", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\65\6\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\66\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\67\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\70\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\71\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\72\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\73\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\74\26\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\75\12\33", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\0\76", + "\42\56\1\57\71\56\1\55\uffa3\56", + "\1\53", + "\0\100", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\53", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\101\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\102\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\14\33\1\103\15\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\104\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\105\31\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\13\33\1\106\16\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\107\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\110\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\111\25\33", + "\42\56\1\57\71\56\1\55\uffa3\56", + "", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\112\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\113\14\33", + "\1\22\12\33\7\uffff\6\33\1\114\23\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\115\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\14\33\1\116\15\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\117\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\5\33\1\120\24\33", + "\1\22\12\33\1\121\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\123\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\124\14\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\125\26\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\126\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\127\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\130\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\131\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\132\31\33", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\133\31\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\134\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\135\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\136\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\137\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\7\33\1\140\22\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\141\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\13\33\1\142\16\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\143\14\33", + "\1\22\12\33\7\uffff\21\33\1\144\10\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\145\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\146\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\147\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\150\6\33", + "\1\22\12\33\7\uffff\3\33\1\151\26\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\152\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\153\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\154\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\155\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\156\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\157\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\160\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\161\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\162\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\163\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\164\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\165\7\33", + "\1\22\12\33\1\166\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\167\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\170\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\171\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\172\7\33", + "\1\22\12\33\1\173\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\174\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\175\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\176\7\33", + "\1\22\12\33\1\177\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\u0080\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\u0081\14\33", + "\1\22\12\33\1\u0082\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\u0083\26\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\u0084\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\u0085\14\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\u0086\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\30\33\1\u0087\1\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "" + }; + + static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); + static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); + static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); + static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); + static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); + static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); + static final short[][] DFA12_transition; + + static { + int numStates = DFA12_transitionS.length; + DFA12_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA12_62<='!')||(LA12_62>='#' && LA12_62<='[')||(LA12_62>=']' && LA12_62<='\uFFFF')) ) {s = 46;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA12_46 = input.LA(1); + + s = -1; + if ( (LA12_46=='\"') ) {s = 47;} + + else if ( (LA12_46=='\\') ) {s = 45;} + + else if ( ((LA12_46>='\u0000' && LA12_46<='!')||(LA12_46>='#' && LA12_46<='[')||(LA12_46>=']' && LA12_46<='\uFFFF')) ) {s = 46;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA12_64 = input.LA(1); + + s = -1; + if ( (LA12_64=='\'') ) {s = 50;} + + else if ( (LA12_64=='\\') ) {s = 48;} + + else if ( ((LA12_64>='\u0000' && LA12_64<='&')||(LA12_64>='(' && LA12_64<='[')||(LA12_64>=']' && LA12_64<='\uFFFF')) ) {s = 49;} + + if ( s>=0 ) return s; + break; + case 3 : + int LA12_49 = input.LA(1); + + s = -1; + if ( (LA12_49=='\'') ) {s = 50;} + + else if ( (LA12_49=='\\') ) {s = 48;} + + else if ( ((LA12_49>='\u0000' && LA12_49<='&')||(LA12_49>='(' && LA12_49<='[')||(LA12_49>=']' && LA12_49<='\uFFFF')) ) {s = 49;} + + if ( s>=0 ) return s; + break; + case 4 : + int LA12_45 = input.LA(1); + + s = -1; + if ( ((LA12_45>='\u0000' && LA12_45<='\uFFFF')) ) {s = 62;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA12_48 = input.LA(1); + + s = -1; + if ( ((LA12_48>='\u0000' && LA12_48<='\uFFFF')) ) {s = 64;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA12_19 = input.LA(1); + + s = -1; + if ( (LA12_19=='\\') ) {s = 45;} + + else if ( ((LA12_19>='\u0000' && LA12_19<='!')||(LA12_19>='#' && LA12_19<='[')||(LA12_19>=']' && LA12_19<='\uFFFF')) ) {s = 46;} + + else if ( (LA12_19=='\"') ) {s = 47;} + + else s = 24; + + if ( s>=0 ) return s; + break; + case 7 : + int LA12_20 = input.LA(1); + + s = -1; + if ( (LA12_20=='\\') ) {s = 48;} + + else if ( ((LA12_20>='\u0000' && LA12_20<='&')||(LA12_20>='(' && LA12_20<='[')||(LA12_20>=']' && LA12_20<='\uFFFF')) ) {s = 49;} + + else if ( (LA12_20=='\'') ) {s = 50;} + + else s = 24; + + if ( s>=0 ) return s; + break; + case 8 : + int LA12_0 = input.LA(1); + + s = -1; + if ( (LA12_0=='E') ) {s = 1;} + + else if ( (LA12_0=='d') ) {s = 2;} + + else if ( (LA12_0=='f') ) {s = 3;} + + else if ( (LA12_0=='s') ) {s = 4;} + + else if ( (LA12_0=='p') ) {s = 5;} + + else if ( (LA12_0=='a') ) {s = 6;} + + else if ( (LA12_0=='n') ) {s = 7;} + + else if ( (LA12_0=='t') ) {s = 8;} + + else if ( (LA12_0==',') ) {s = 9;} + + else if ( (LA12_0==':') ) {s = 10;} + + else if ( (LA12_0=='[') ) {s = 11;} + + else if ( (LA12_0==']') ) {s = 12;} + + else if ( (LA12_0=='}') ) {s = 13;} + + else if ( (LA12_0=='#') ) {s = 14;} + + else if ( (LA12_0=='/') ) {s = 15;} + + else if ( (LA12_0=='^') ) {s = 16;} + + else if ( ((LA12_0>='A' && LA12_0<='D')||(LA12_0>='F' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='b' && LA12_0<='c')||LA12_0=='e'||(LA12_0>='g' && LA12_0<='m')||LA12_0=='o'||(LA12_0>='q' && LA12_0<='r')||(LA12_0>='u' && LA12_0<='z')) ) {s = 17;} + + else if ( (LA12_0=='\"') ) {s = 19;} + + else if ( (LA12_0=='\'') ) {s = 20;} + + else if ( (LA12_0=='~') ) {s = 21;} + + else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 22;} + + else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 23;} + + else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||LA12_0=='!'||(LA12_0>='$' && LA12_0<='&')||(LA12_0>='(' && LA12_0<='+')||(LA12_0>='-' && LA12_0<='.')||(LA12_0>=';' && LA12_0<='@')||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='{' && LA12_0<='|')||(LA12_0>='\u007F' && LA12_0<='\uFFFF')) ) {s = 24;} + + else s = 18; + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 12, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.tokens b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.tokens new file mode 100644 index 000000000..85f28ff2c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src-gen/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/lexer/InternalRos1Lexer.tokens @@ -0,0 +1,26 @@ +Artifacts=10 +Colon=15 +Comma=14 +Dependencies=5 +ExternalDependency=4 +FromGitRepo=6 +LeftSquareBracket=16 +Node=13 +Node_1=11 +Parameters=8 +Publishers=9 +RULE_ANY_OTHER=29 +RULE_BEGIN=19 +RULE_END=20 +RULE_ID=22 +RULE_INT=26 +RULE_ML_COMMENT=27 +RULE_ROS_CONVENTION_A=23 +RULE_ROS_CONVENTION_PARAM=25 +RULE_SL_COMMENT=21 +RULE_STRING=24 +RULE_WS=28 +RightCurlyBracket=18 +RightSquareBracket=17 +Subscribers=7 +Type=12 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeModule.java new file mode 100644 index 000000000..837758ede --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeModule.java @@ -0,0 +1,11 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide; + + +/** + * Use this class to register ide components. + */ +public class Ros1IdeModule extends AbstractRos1IdeModule { +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeSetup.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeSetup.java new file mode 100644 index 000000000..c2e400c1b --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/Ros1IdeSetup.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros1.Ros1RuntimeModule; +import de.fraunhofer.ipa.ros1.Ros1StandaloneSetup; +import org.eclipse.xtext.util.Modules2; + +/** + * Initialization support for running Xtext languages as language servers. + */ +public class Ros1IdeSetup extends Ros1StandaloneSetup { + + @Override + public Injector createInjector() { + return Guice.createInjector(Modules2.mixin(new Ros1RuntimeModule(), new Ros1IdeModule())); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1TokenSource.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1TokenSource.java new file mode 100644 index 000000000..40a90036d --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ide/src/de/fraunhofer/ipa/ros1/ide/contentassist/antlr/Ros1TokenSource.java @@ -0,0 +1,39 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ide.contentassist.antlr; + +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.internal.InternalRos1Parser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class Ros1TokenSource extends AbstractIndentationTokenSource { + + public Ros1TokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRos1Parser.RULE_WS; + } + + @Override + protected int getBeginTokenType() { + // TODO Review assumption + return InternalRos1Parser.RULE_BEGIN; + } + + @Override + protected int getEndTokenType() { + // TODO Review assumption + return InternalRos1Parser.RULE_END; + } + + @Override + protected boolean shouldEmitPendingEndTokens() { + return false; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.classpath b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.project b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.project new file mode 100644 index 000000000..e401bbf82 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros1.xtext.ui + + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.jdt.core.javanature + org.eclipse.pde.PluginNature + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,10 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.compliance=11 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/META-INF/MANIFEST.MF new file mode 100644 index 000000000..569dcbdce --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/META-INF/MANIFEST.MF @@ -0,0 +1,25 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros1.xtext.ui +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros1.xtext.ui +Bundle-Vendor: My Company +Bundle-Version: 1.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros1.xtext.ui; singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: de.fraunhofer.ipa.ros1.xtext, + de.fraunhofer.ipa.ros1.xtext.ide, + de.fraunhofer.ipa.ros, + org.eclipse.xtext.ui, + org.eclipse.xtext.ui.shared, + org.eclipse.xtext.ui.codetemplates.ui, + org.eclipse.ui.editors;bundle-version="3.5.0", + org.eclipse.ui.ide;bundle-version="3.5.0", + org.eclipse.ui, + org.eclipse.compare, + org.eclipse.xtext.builder +Import-Package: org.apache.log4j +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Export-Package: de.fraunhofer.ipa.ros1.xtext.ui.internal, + de.fraunhofer.ipa.ros1.ui.quickfix, + de.fraunhofer.ipa.ros1.ui.contentassist +Bundle-Activator: de.fraunhofer.ipa.ros1.xtext.ui.internal.XtextActivator diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/build.properties b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/build.properties new file mode 100644 index 000000000..323f56c51 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/build.properties @@ -0,0 +1,7 @@ +source.. = src/,\ + src-gen/,\ + xtend-gen/ +bin.includes = .,\ + META-INF/,\ + plugin.xml +bin.excludes = **/*.xtend diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/plugin.xml b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/plugin.xml new file mode 100644 index 000000000..dcef37fbd --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/plugin.xml @@ -0,0 +1,434 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/AbstractRos1UiModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/AbstractRos1UiModule.java new file mode 100644 index 000000000..ffad7292f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/AbstractRos1UiModule.java @@ -0,0 +1,300 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.PartialRos1ContentAssistParser; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.Ros1Parser; +import de.fraunhofer.ipa.ros1.ide.contentassist.antlr.lexer.InternalRos1Lexer; +import de.fraunhofer.ipa.ros1.ui.contentassist.Ros1ProposalProvider; +import de.fraunhofer.ipa.ros1.ui.labeling.Ros1DescriptionLabelProvider; +import de.fraunhofer.ipa.ros1.ui.labeling.Ros1LabelProvider; +import de.fraunhofer.ipa.ros1.ui.outline.Ros1OutlineTreeProvider; +import de.fraunhofer.ipa.ros1.ui.quickfix.Ros1QuickfixProvider; +import de.fraunhofer.ipa.ros1.validation.Ros1ValidatorConfigurationBlock; +import org.eclipse.compare.IViewerCreator; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.eclipse.xtext.builder.BuilderParticipant; +import org.eclipse.xtext.builder.EclipseOutputConfigurationProvider; +import org.eclipse.xtext.builder.IXtextBuilderParticipant; +import org.eclipse.xtext.builder.builderState.IBuilderState; +import org.eclipse.xtext.builder.clustering.CurrentDescriptions; +import org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource; +import org.eclipse.xtext.builder.nature.NatureAddingEditorCallback; +import org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess; +import org.eclipse.xtext.generator.IContextualOutputConfigurationProvider; +import org.eclipse.xtext.ide.LexerIdeBindings; +import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider; +import org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider; +import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser; +import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider; +import org.eclipse.xtext.parser.antlr.ITokenDefProvider; +import org.eclipse.xtext.parser.antlr.LexerProvider; +import org.eclipse.xtext.resource.IResourceDescriptions; +import org.eclipse.xtext.resource.containers.IAllContainersState; +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; +import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.ui.DefaultUiModule; +import org.eclipse.xtext.ui.UIBindings; +import org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator; +import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialEditingContentAssistContextFactory; +import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.PartialEditingContentAssistContextFactory; +import org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage; +import org.eclipse.xtext.ui.codetemplates.ui.preferences.TemplatesLanguageConfiguration; +import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar; +import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistry; +import org.eclipse.xtext.ui.compare.DefaultViewerCreator; +import org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource; +import org.eclipse.xtext.ui.editor.IXtextEditorCallback; +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; +import org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher; +import org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider; +import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper; +import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher; +import org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper; +import org.eclipse.xtext.ui.editor.contentassist.antlr.DelegatingContentAssistContextFactory; +import org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider; +import org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider; +import org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer; +import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider; +import org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage; +import org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator; +import org.eclipse.xtext.ui.refactoring.IReferenceUpdater; +import org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider; +import org.eclipse.xtext.ui.refactoring.IRenameStrategy; +import org.eclipse.xtext.ui.refactoring.impl.DefaultDependentElementsCalculator; +import org.eclipse.xtext.ui.refactoring.impl.DefaultReferenceUpdater; +import org.eclipse.xtext.ui.refactoring.impl.DefaultRenameRefactoringProvider; +import org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategy; +import org.eclipse.xtext.ui.refactoring.ui.DefaultRenameSupport; +import org.eclipse.xtext.ui.refactoring.ui.IRenameSupport; +import org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences; +import org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider; +import org.eclipse.xtext.ui.shared.Access; +import org.eclipse.xtext.ui.validation.AbstractValidatorConfigurationBlock; + +/** + * Manual modifications go to {@link Ros1UiModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos1UiModule extends DefaultUiModule { + + public AbstractRos1UiModule(AbstractUIPlugin plugin) { + super(plugin); + } + + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Provider provideIAllContainersState() { + return Access.getJavaProjectsState(); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIProposalConflictHelper() { + return AntlrProposalConflictHelper.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureContentAssistLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST)) + .to(InternalRos1Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureHighlightingLexer(Binder binder) { + binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class) + .annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING)) + .to(de.fraunhofer.ipa.ros1.parser.antlr.lexer.InternalRos1Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureHighlightingTokenDefProvider(Binder binder) { + binder.bind(ITokenDefProvider.class) + .annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING)) + .to(AntlrTokenDefProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindContentAssistContext$Factory() { + return DelegatingContentAssistContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIContentAssistParser() { + return Ros1Parser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureContentAssistLexerProvider(Binder binder) { + binder.bind(InternalRos1Lexer.class).toProvider(LexerProvider.create(InternalRos1Lexer.class)); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindCompletionPrefixProvider() { + return IndentationAwareCompletionPrefixProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + public Class bindAbstractValidatorConfigurationBlock() { + return Ros1ValidatorConfigurationBlock.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIDependentElementsCalculator() { + return DefaultDependentElementsCalculator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptionsBuilderScope(Binder binder) { + binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIXtextEditorCallback() { + return NatureAddingEditorCallback.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIContextualOutputConfigurationProvider() { + return EclipseOutputConfigurationProvider.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(IBuilderState.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindDocumentBasedDirtyResource() { + return PersistentDataAwareDirtyResource.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public Class bindIXtextBuilderParticipant() { + return BuilderParticipant.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public IWorkspaceRoot bindIWorkspaceRootToInstance() { + return ResourcesPlugin.getWorkspace().getRoot(); + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public void configureBuilderPreferenceStoreInitializer(Binder binder) { + binder.bind(IPreferenceStoreInitializer.class) + .annotatedWith(Names.named("builderPreferenceInitializer")) + .to(BuilderPreferenceAccess.Initializer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2 + public Class bindILabelProvider() { + return Ros1LabelProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2 + public void configureResourceUIServiceLabelProvider(Binder binder) { + binder.bind(ILabelProvider.class).annotatedWith(ResourceServiceDescriptionLabelProvider.class).to(Ros1DescriptionLabelProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2 + public Class bindIOutlineTreeProvider() { + return Ros1OutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2 + public Class bindIOutlineTreeStructureProvider() { + return Ros1OutlineTreeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.quickfix.QuickfixProviderFragment2 + public Class bindIssueResolutionProvider() { + return Ros1QuickfixProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.contentAssist.ContentAssistFragment2 + public Class bindIContentProposalProvider() { + return Ros1ProposalProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public void configureIPreferenceStoreInitializer(Binder binder) { + binder.bind(IPreferenceStoreInitializer.class) + .annotatedWith(Names.named("RefactoringPreferences")) + .to(RefactoringPreferences.Initializer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameStrategy() { + return DefaultRenameStrategy.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIReferenceUpdater() { + return DefaultReferenceUpdater.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameRefactoringProvider() { + return DefaultRenameRefactoringProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameSupport$Factory() { + return DefaultRenameSupport.Factory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + public Provider provideTemplatesLanguageConfiguration() { + return AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider(); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + public Provider provideLanguageRegistry() { + return AccessibleCodetemplatesActivator.getLanguageRegistry(); + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + @SingletonBinding(eager=true) + public Class bindLanguageRegistrar() { + return LanguageRegistrar.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + public Class bindXtextTemplatePreferencePage() { + return AdvancedTemplatesPreferencePage.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + public Class bindIPartialEditingContentAssistParser() { + return PartialRos1ContentAssistParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2 + public Class bindIPartialEditingContentAssistContextFactory() { + return PartialEditingContentAssistContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.compare.CompareFragment2 + public Class bindIViewerCreator() { + return DefaultViewerCreator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.compare.CompareFragment2 + public void configureCompareViewerTitle(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(UIBindings.COMPARE_VIEWER_TITLE)).toInstance("Ros1 Compare"); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/Ros1ExecutableExtensionFactory.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/Ros1ExecutableExtensionFactory.java new file mode 100644 index 000000000..6d906a3f0 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/Ros1ExecutableExtensionFactory.java @@ -0,0 +1,29 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui; + +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros1.xtext.ui.internal.XtextActivator; +import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory; +import org.osgi.framework.Bundle; +import org.osgi.framework.FrameworkUtil; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class Ros1ExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory { + + @Override + protected Bundle getBundle() { + return FrameworkUtil.getBundle(XtextActivator.class); + } + + @Override + protected Injector getInjector() { + XtextActivator activator = XtextActivator.getInstance(); + return activator != null ? activator.getInjector(XtextActivator.DE_FRAUNHOFER_IPA_ROS1_ROS1) : null; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/contentassist/AbstractRos1ProposalProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/contentassist/AbstractRos1ProposalProvider.java new file mode 100644 index 000000000..a6fed937e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/ui/contentassist/AbstractRos1ProposalProvider.java @@ -0,0 +1,124 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.contentassist; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.CrossReference; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider; +import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; +import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; + +/** + * Represents a generated, default implementation of superclass {@link TerminalsProposalProvider}. + * Methods are dynamically dispatched on the first parameter, i.e., you can override them + * with a more concrete subtype. + */ +public abstract class AbstractRos1ProposalProvider extends TerminalsProposalProvider { + + public void completeCatkinPackage_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeCatkinPackage_FromGitRepo(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeCatkinPackage_Artifact(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeCatkinPackage_Dependency(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeArtifact_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeArtifact_Node(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeNode_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeNode_Publisher(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeNode_Subscriber(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeNode_Parameter(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completePublisher_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completePublisher_Message(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeSubscriber_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completeSubscriber_Message(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeParameter_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + public void completePackageDependency_Package(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); + } + public void completeExternalDependency_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); + } + + public void complete_CatkinPackage(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Artifact(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Node(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Publisher(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Subscriber(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Parameter(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_BEGIN(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_END(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_SL_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_Dependency(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_PackageDependency(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_ExternalDependency(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_RosNames(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_EString(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_RosParamNames(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_ROS_CONVENTION_A(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } + public void complete_ROS_CONVENTION_PARAM(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { + // subclasses may override + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ValidatorConfigurationBlock.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ValidatorConfigurationBlock.java new file mode 100644 index 000000000..c4393aaf6 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ValidatorConfigurationBlock.java @@ -0,0 +1,35 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.validation; + +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.xtext.ui.validation.AbstractValidatorConfigurationBlock; + +@SuppressWarnings("restriction") +public class Ros1ValidatorConfigurationBlock extends AbstractValidatorConfigurationBlock { + + protected static final String SETTINGS_SECTION_NAME = "Ros1"; + + @Override + protected void fillSettingsPage(Composite composite, int nColumns, int defaultIndent) { + addComboBox(Ros1ConfigurableIssueCodesProvider.DEPRECATED_MODEL_PART, "Deprecated Model Part", composite, defaultIndent); + } + + @Override + public void dispose() { + storeSectionExpansionStates(getDialogSettings()); + super.dispose(); + } + + @Override + protected IDialogSettings getDialogSettings() { + IDialogSettings dialogSettings = super.getDialogSettings(); + IDialogSettings section = dialogSettings.getSection(SETTINGS_SECTION_NAME); + if (section == null) { + return dialogSettings.addNewSection(SETTINGS_SECTION_NAME); + } + return section; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/xtext/ui/internal/XtextActivator.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/xtext/ui/internal/XtextActivator.java new file mode 100644 index 000000000..213cad7f4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src-gen/de/fraunhofer/ipa/ros1/xtext/ui/internal/XtextActivator.java @@ -0,0 +1,94 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.xtext.ui.internal; + +import com.google.common.collect.Maps; +import com.google.inject.Guice; +import com.google.inject.Injector; +import de.fraunhofer.ipa.ros1.Ros1RuntimeModule; +import de.fraunhofer.ipa.ros1.ui.Ros1UiModule; +import java.util.Collections; +import java.util.Map; +import org.apache.log4j.Logger; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.eclipse.xtext.ui.shared.SharedStateModule; +import org.eclipse.xtext.util.Modules2; +import org.osgi.framework.BundleContext; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class XtextActivator extends AbstractUIPlugin { + + public static final String PLUGIN_ID = "de.fraunhofer.ipa.ros1.xtext.ui"; + public static final String DE_FRAUNHOFER_IPA_ROS1_ROS1 = "de.fraunhofer.ipa.ros1.Ros1"; + + private static final Logger logger = Logger.getLogger(XtextActivator.class); + + private static XtextActivator INSTANCE; + + private Map injectors = Collections.synchronizedMap(Maps. newHashMapWithExpectedSize(1)); + + @Override + public void start(BundleContext context) throws Exception { + super.start(context); + INSTANCE = this; + } + + @Override + public void stop(BundleContext context) throws Exception { + injectors.clear(); + INSTANCE = null; + super.stop(context); + } + + public static XtextActivator getInstance() { + return INSTANCE; + } + + public Injector getInjector(String language) { + synchronized (injectors) { + Injector injector = injectors.get(language); + if (injector == null) { + injectors.put(language, injector = createInjector(language)); + } + return injector; + } + } + + protected Injector createInjector(String language) { + try { + com.google.inject.Module runtimeModule = getRuntimeModule(language); + com.google.inject.Module sharedStateModule = getSharedStateModule(); + com.google.inject.Module uiModule = getUiModule(language); + com.google.inject.Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule); + return Guice.createInjector(mergedModule); + } catch (Exception e) { + logger.error("Failed to create injector for " + language); + logger.error(e.getMessage(), e); + throw new RuntimeException("Failed to create injector for " + language, e); + } + } + + protected com.google.inject.Module getRuntimeModule(String grammar) { + if (DE_FRAUNHOFER_IPA_ROS1_ROS1.equals(grammar)) { + return new Ros1RuntimeModule(); + } + throw new IllegalArgumentException(grammar); + } + + protected com.google.inject.Module getUiModule(String grammar) { + if (DE_FRAUNHOFER_IPA_ROS1_ROS1.equals(grammar)) { + return new Ros1UiModule(this); + } + throw new IllegalArgumentException(grammar); + } + + protected com.google.inject.Module getSharedStateModule() { + return new SharedStateModule(); + } + + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/Ros1UiModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/Ros1UiModule.java new file mode 100644 index 000000000..31e9aea13 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/Ros1UiModule.java @@ -0,0 +1,16 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui; + +import org.eclipse.ui.plugin.AbstractUIPlugin; + +/** + * Use this class to register components to be used within the Eclipse IDE. + */ +public class Ros1UiModule extends AbstractRos1UiModule { + + public Ros1UiModule(AbstractUIPlugin plugin) { + super(plugin); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/contentassist/Ros1ProposalProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/contentassist/Ros1ProposalProvider.java new file mode 100644 index 000000000..527f532e2 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/contentassist/Ros1ProposalProvider.java @@ -0,0 +1,12 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.contentassist; + + +/** + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#content-assist + * on how to customize the content assistant. + */ +public class Ros1ProposalProvider extends AbstractRos1ProposalProvider { +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1DescriptionLabelProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1DescriptionLabelProvider.java new file mode 100644 index 000000000..f0dd43efd --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1DescriptionLabelProvider.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.labeling; + +import org.eclipse.xtext.ui.label.DefaultDescriptionLabelProvider; + +/** + * Provides labels for IEObjectDescriptions and IResourceDescriptions. + * + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#label-provider + */ +public class Ros1DescriptionLabelProvider extends DefaultDescriptionLabelProvider { + + // Labels and icons can be computed like this: +// @Override +// public String text(IEObjectDescription ele) { +// return ele.getName().toString(); +// } +// +// @Override +// public String image(IEObjectDescription ele) { +// return ele.getEClass().getName() + ".gif"; +// } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1LabelProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1LabelProvider.java new file mode 100644 index 000000000..f5ce73a34 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/labeling/Ros1LabelProvider.java @@ -0,0 +1,31 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.labeling; + +import com.google.inject.Inject; +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; +import org.eclipse.xtext.ui.label.DefaultEObjectLabelProvider; + +/** + * Provides labels for EObjects. + * + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#label-provider + */ +public class Ros1LabelProvider extends DefaultEObjectLabelProvider { + + @Inject + public Ros1LabelProvider(AdapterFactoryLabelProvider delegate) { + super(delegate); + } + + // Labels and icons can be computed like this: + +// String text(Greeting ele) { +// return "A greeting to " + ele.getName(); +// } +// +// String image(Greeting ele) { +// return "Greeting.gif"; +// } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/outline/Ros1OutlineTreeProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/outline/Ros1OutlineTreeProvider.java new file mode 100644 index 000000000..249e7befa --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/outline/Ros1OutlineTreeProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.outline; + +import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider; + +/** + * Customization of the default outline structure. + * + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#outline + */ +public class Ros1OutlineTreeProvider extends DefaultOutlineTreeProvider { + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/quickfix/Ros1QuickfixProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/quickfix/Ros1QuickfixProvider.java new file mode 100644 index 000000000..c40d09eb4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext.ui/src/de/fraunhofer/ipa/ros1/ui/quickfix/Ros1QuickfixProvider.java @@ -0,0 +1,26 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.ui.quickfix; + +import org.eclipse.xtext.ui.editor.quickfix.DefaultQuickfixProvider; + +/** + * Custom quickfixes. + * + * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#quick-fixes + */ +public class Ros1QuickfixProvider extends DefaultQuickfixProvider { + +// @Fix(Ros1Validator.INVALID_NAME) +// public void capitalizeName(final Issue issue, IssueResolutionAcceptor acceptor) { +// acceptor.accept(issue, "Capitalize name", "Capitalize the name.", "upcase.png", new IModification() { +// public void apply(IModificationContext context) throws BadLocationException { +// IXtextDocument xtextDocument = context.getXtextDocument(); +// String firstLetter = xtextDocument.get(issue.getOffset(), 1); +// xtextDocument.replace(issue.getOffset(), 1, firstLetter.toUpperCase()); +// } +// }); +// } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.classpath b/plugins/de.fraunhofer.ipa.ros1.xtext/.classpath new file mode 100644 index 000000000..a61354428 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Generate Ros1 (ros1) Language Infrastructure.launch b/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Generate Ros1 (ros1) Language Infrastructure.launch new file mode 100644 index 000000000..af7be0d9f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Generate Ros1 (ros1) Language Infrastructure.launch @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Launch Runtime Eclipse.launch b/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Launch Runtime Eclipse.launch new file mode 100644 index 000000000..e838c5ee8 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.launch/Launch Runtime Eclipse.launch @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.project b/plugins/de.fraunhofer.ipa.ros1.xtext/.project new file mode 100644 index 000000000..563bdc9db --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.project @@ -0,0 +1,34 @@ + + + de.fraunhofer.ipa.ros1.xtext + + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.jdt.core.javanature + org.eclipse.pde.PluginNature + + diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.core.resources.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..99f26c020 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.jdt.core.prefs b/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..7adc0fb9a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,10 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.compliance=11 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/META-INF/MANIFEST.MF b/plugins/de.fraunhofer.ipa.ros1.xtext/META-INF/MANIFEST.MF new file mode 100644 index 000000000..fb19a3775 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/META-INF/MANIFEST.MF @@ -0,0 +1,27 @@ +Manifest-Version: 1.0 +Automatic-Module-Name: de.fraunhofer.ipa.ros1.xtext +Bundle-ManifestVersion: 2 +Bundle-Name: de.fraunhofer.ipa.ros1.xtext +Bundle-Vendor: My Company +Bundle-Version: 1.0.0.qualifier +Bundle-SymbolicName: de.fraunhofer.ipa.ros1.xtext; singleton:=true +Bundle-ActivationPolicy: lazy +Require-Bundle: de.fraunhofer.ipa.ros, + org.eclipse.xtext, + org.eclipse.xtext.xbase, + org.eclipse.equinox.common;bundle-version="3.5.0", + org.eclipse.xtext.xbase.lib;bundle-version="2.14.0", + org.eclipse.xtext.util, + org.antlr.runtime;bundle-version="[3.2.0,3.2.1)" +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Export-Package: de.fraunhofer.ipa.ros1.parser.antlr, + de.fraunhofer.ipa.ros1.formatting2, + de.fraunhofer.ipa.ros1.parser.antlr.internal, + de.fraunhofer.ipa.ros1.services, + de.fraunhofer.ipa.ros1.validation, + de.fraunhofer.ipa.ros1, + de.fraunhofer.ipa.ros1.generator, + de.fraunhofer.ipa.ros1.parser.antlr.lexer, + de.fraunhofer.ipa.ros1.serializer, + de.fraunhofer.ipa.ros1.scoping +Import-Package: org.apache.log4j diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/build.properties b/plugins/de.fraunhofer.ipa.ros1.xtext/build.properties new file mode 100644 index 000000000..c24ff3680 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/build.properties @@ -0,0 +1,17 @@ +source.. = src/,\ + src-gen/,\ + xtend-gen/ +bin.includes = .,\ + META-INF/ +bin.excludes = **/*.mwe2,\ + **/*.xtend +additional.bundles = org.eclipse.xtext.xbase,\ + org.eclipse.xtext.common.types,\ + org.eclipse.xtext.xtext.generator,\ + org.eclipse.emf.codegen.ecore,\ + org.eclipse.emf.mwe.utils,\ + org.eclipse.emf.mwe2.launch,\ + org.eclipse.emf.mwe2.lib,\ + org.objectweb.asm,\ + org.apache.commons.logging,\ + org.apache.log4j diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/AbstractRos1RuntimeModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/AbstractRos1RuntimeModule.java new file mode 100644 index 000000000..7568fbd8b --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/AbstractRos1RuntimeModule.java @@ -0,0 +1,208 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import de.fraunhofer.ipa.ros1.generator.Ros1Generator; +import de.fraunhofer.ipa.ros1.parser.antlr.Ros1AntlrTokenFileProvider; +import de.fraunhofer.ipa.ros1.parser.antlr.Ros1Parser; +import de.fraunhofer.ipa.ros1.parser.antlr.lexer.InternalRos1Lexer; +import de.fraunhofer.ipa.ros1.scoping.Ros1ScopeProvider; +import de.fraunhofer.ipa.ros1.serializer.Ros1SemanticSequencer; +import de.fraunhofer.ipa.ros1.serializer.Ros1SyntacticSequencer; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; +import de.fraunhofer.ipa.ros1.validation.Ros1ConfigurableIssueCodesProvider; +import de.fraunhofer.ipa.ros1.validation.Ros1Validator; +import java.util.Properties; +import org.eclipse.xtext.Constants; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.common.services.Ecore2XtextTerminalConverters; +import org.eclipse.xtext.conversion.IValueConverterService; +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.DefaultGlobalScopeProvider; +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.DefaultRuntimeModule; +import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; + +/** + * Manual modifications go to {@link Ros1RuntimeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractRos1RuntimeModule extends DefaultRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(Binder binder) { + properties = tryBindProperties(binder, "de/fraunhofer/ipa/ros1/Ros1.properties"); + super.configure(binder); + } + + public void configureLanguageName(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("de.fraunhofer.ipa.ros1.Ros1"); + } + + 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("ros1"); + } + + // 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 Ros1GrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISemanticSequencer() { + return Ros1SemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return Ros1SyntacticSequencer.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 Ros1Parser.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 Ros1AntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalRos1Lexer.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 provideInternalRos1Lexer() { + return LexerProvider.create(InternalRos1Lexer.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(InternalRos1Lexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager=true) + public Class bindRos1Validator() { + return Ros1Validator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + public Class bindConfigurableIssueCodesProvider() { + return Ros1ConfigurableIssueCodesProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIScopeProvider() { + return Ros1ScopeProvider.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 Class bindIGlobalScopeProvider() { + return DefaultGlobalScopeProvider.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 Ros1Generator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ecore2xtext.Ecore2XtextValueConverterServiceFragment2 + public Class bindIValueConverterService() { + return Ecore2XtextTerminalConverters.class; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1.xtextbin b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/Ros1.xtextbin new file mode 100644 index 0000000000000000000000000000000000000000..af050a2bc8bcce0ea83df3181aeb19cc2c3bcb4c GIT binary patch literal 3804 zcma)9cYGX271rC?*=sr#TXGVUKw?7@AS6X!yjC*Z&JZObyj#ubM6jwu4)8e6F02tfJW5@eJb~;{dHJdGed{G5W&vzT4 zIZ{(~&sX6duU1q3Vr#$hLy*Ol4WFg}qnK(`RvRh-Bla!`8LhXK2_m~lV@1`Cd{aek zvsF_K3FZi`s6hEuRhvzhjhvcytNYz$Wf`ab50Z#SCTf>ms3J!1I^EEV_+I1-=`32UM6P9-Ix| zMt{`}YD}9Kts6UJPBm0h`B5lyU}eu!>uar`CanW*V^tX^Lmn(?atd`wK)nco?;f-~joB&datqK0S z@K9ubvfuUnRzy^_{LnZN@&%{!ofJrJ?tlscuciR3EuFfUqT}EOT1{rGfC?(io@puWq={zn0+!Lf>j7d30GCO#Uw9nv?^zKD#<2)xln@7^y$>S27 zNn5*kO5gY9@oZ)V?n8l?GnCi+#*y65F#3!PRoILlfq8!@^v1J8o~2Ekotl^+1DS=z z%1n7$JRoJ`ft-SKn34yv+&0*qfEI|HQ6zZMxD4=I=+Eu-8Z|Cd0Gx!J#3|Orl9qUI zqEAS1T2FBg8^#&_JPq(6sp<1#)8}i&St?<`GFzOBEzawWhbDS#vC^3qap9PH#Kkli zydd^>AqflH2HXodP5@pMo4uHA6x^oi3q^dIh}8(M2k+3mnHs86zG$KQEpk-qLi7~h9QYp67$2Axdm!$ zt5wb#W&Z#vpF~L4;?;xk7p^CplrX@nlBGw`lJx0j z;YGklvcv@7)$IEa`L@n2P0y4CKC0vJ(IheyuKUr7ioEJXyw9qSp?ady5%^dVDAt2k zbJ~k4s@)=UkAp$kzhTKDYVh&w<1lfM)fa`pCv?0#F|OJtkqD_@6Jt#fJ~?qC@hRk{ z;0BRbr)CwB)U^p_ybcC?3!9p5Drbou6)-ig&?2v7 zEMqd?*-ZF&6>r~6i1PEPmcUnQSg&DN{kGlNB5bdXvAvENd3`EIp}(OA;2YWMVOoBZ zX5`Hp#alQge&P_aw~|Vh%0G;sF2v*8V0dtnj(OO5<>>SGcJ1gL8qZ>@?Nt}rstQ*3 zl)Y2?1bi3Ij!*@grSg=(cawHPvc#Urr z7)jt?)&9Pg)=;{c#Qk;NzBR6)bVJ}bwC8W8HI!~q)ZdCv)wen7@1$ZB-gkSV{vKQ9 zsK2kH{((mELmrO+{)pGFPNMj6vIh7QJ)vd%>4y2wQh}c*VOsbLQXi(@%Rg2f-O?Wfjg16!!JhB;&;%#_4Hu12N zr#J`bTBQeq+f43Or$CV7", "", "", "", "ExternalDependency", "Dependencies", "FromGitRepo", "Subscribers", "Parameters", "Publishers", "Artifacts", "Node_1", "Type", "Node", "Comma", "Colon", "LeftSquareBracket", "RightSquareBracket", "RightCurlyBracket", "RULE_BEGIN", "RULE_END", "RULE_SL_COMMENT", "RULE_ID", "RULE_ROS_CONVENTION_A", "RULE_STRING", "RULE_ROS_CONVENTION_PARAM", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" + }; + public static final int RULE_END=20; + public static final int RULE_BEGIN=19; + public static final int Node=13; + public static final int RULE_STRING=24; + public static final int RULE_SL_COMMENT=21; + public static final int Comma=14; + public static final int RULE_ROS_CONVENTION_A=23; + public static final int Publishers=9; + public static final int RULE_ROS_CONVENTION_PARAM=25; + public static final int Dependencies=5; + public static final int Colon=15; + public static final int RightCurlyBracket=18; + public static final int EOF=-1; + public static final int RightSquareBracket=17; + public static final int FromGitRepo=6; + public static final int ExternalDependency=4; + public static final int Parameters=8; + public static final int RULE_ID=22; + public static final int RULE_WS=28; + public static final int RULE_ANY_OTHER=29; + public static final int Artifacts=10; + public static final int Node_1=11; + public static final int Type=12; + public static final int RULE_INT=26; + public static final int RULE_ML_COMMENT=27; + public static final int LeftSquareBracket=16; + public static final int Subscribers=7; + + // delegates + // delegators + + + public InternalRos1Parser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos1Parser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalRos1Parser.tokenNames; } + public String getGrammarFileName() { return "InternalRos1Parser.g"; } + + + + private Ros1GrammarAccess grammarAccess; + + public InternalRos1Parser(TokenStream input, Ros1GrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "CatkinPackage"; + } + + @Override + protected Ros1GrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRuleCatkinPackage" + // InternalRos1Parser.g:57:1: entryRuleCatkinPackage returns [EObject current=null] : iv_ruleCatkinPackage= ruleCatkinPackage EOF ; + public final EObject entryRuleCatkinPackage() throws RecognitionException { + EObject current = null; + + EObject iv_ruleCatkinPackage = null; + + + try { + // InternalRos1Parser.g:57:54: (iv_ruleCatkinPackage= ruleCatkinPackage EOF ) + // InternalRos1Parser.g:58:2: iv_ruleCatkinPackage= ruleCatkinPackage EOF + { + newCompositeNode(grammarAccess.getCatkinPackageRule()); + pushFollow(FOLLOW_1); + iv_ruleCatkinPackage=ruleCatkinPackage(); + + state._fsp--; + + current =iv_ruleCatkinPackage; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleCatkinPackage" + + + // $ANTLR start "ruleCatkinPackage" + // InternalRos1Parser.g:64:1: ruleCatkinPackage returns [EObject current=null] : ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? this_END_16= RULE_END ) ; + public final EObject ruleCatkinPackage() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token this_BEGIN_7=null; + Token this_END_9=null; + Token otherlv_10=null; + Token otherlv_11=null; + Token otherlv_13=null; + Token otherlv_15=null; + Token this_END_16=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + AntlrDatatypeRuleToken lv_fromGitRepo_5_0 = null; + + EObject lv_artifact_8_0 = null; + + EObject lv_dependency_12_0 = null; + + EObject lv_dependency_14_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:70:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? this_END_16= RULE_END ) ) + // InternalRos1Parser.g:71:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? this_END_16= RULE_END ) + { + // InternalRos1Parser.g:71:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? this_END_16= RULE_END ) + // InternalRos1Parser.g:72:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? this_END_16= RULE_END + { + // InternalRos1Parser.g:72:3: () + // InternalRos1Parser.g:73:4: + { + + current = forceCreateModelElement( + grammarAccess.getCatkinPackageAccess().getCatkinPackageAction_0(), + current); + + + } + + // InternalRos1Parser.g:79:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:80:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:80:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:81:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getCatkinPackageAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getCatkinPackageAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_5); + + newLeafNode(this_BEGIN_3, grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos1Parser.g:106:3: (otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==FromGitRepo) ) { + alt1=1; + } + switch (alt1) { + case 1 : + // InternalRos1Parser.g:107:4: otherlv_4= FromGitRepo ( (lv_fromGitRepo_5_0= ruleEString ) ) + { + otherlv_4=(Token)match(input,FromGitRepo,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getCatkinPackageAccess().getFromGitRepoKeyword_4_0()); + + // InternalRos1Parser.g:111:4: ( (lv_fromGitRepo_5_0= ruleEString ) ) + // InternalRos1Parser.g:112:5: (lv_fromGitRepo_5_0= ruleEString ) + { + // InternalRos1Parser.g:112:5: (lv_fromGitRepo_5_0= ruleEString ) + // InternalRos1Parser.g:113:6: lv_fromGitRepo_5_0= ruleEString + { + + newCompositeNode(grammarAccess.getCatkinPackageAccess().getFromGitRepoEStringParserRuleCall_4_1_0()); + + pushFollow(FOLLOW_7); + lv_fromGitRepo_5_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + set( + current, + "fromGitRepo", + lv_fromGitRepo_5_0, + "de.fraunhofer.ipa.ros1.Ros1.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + // InternalRos1Parser.g:131:3: (otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==Artifacts) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // InternalRos1Parser.g:132:4: otherlv_6= Artifacts this_BEGIN_7= RULE_BEGIN ( (lv_artifact_8_0= ruleArtifact ) )* this_END_9= RULE_END + { + otherlv_6=(Token)match(input,Artifacts,FOLLOW_4); + + newLeafNode(otherlv_6, grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()); + + this_BEGIN_7=(Token)match(input,RULE_BEGIN,FOLLOW_8); + + newLeafNode(this_BEGIN_7, grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()); + + // InternalRos1Parser.g:140:4: ( (lv_artifact_8_0= ruleArtifact ) )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==Node||(LA2_0>=RULE_ID && LA2_0<=RULE_ROS_CONVENTION_A)) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalRos1Parser.g:141:5: (lv_artifact_8_0= ruleArtifact ) + { + // InternalRos1Parser.g:141:5: (lv_artifact_8_0= ruleArtifact ) + // InternalRos1Parser.g:142:6: lv_artifact_8_0= ruleArtifact + { + + newCompositeNode(grammarAccess.getCatkinPackageAccess().getArtifactArtifactParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_8); + lv_artifact_8_0=ruleArtifact(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + current, + "artifact", + lv_artifact_8_0, + "de.fraunhofer.ipa.ros1.Ros1.Artifact"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop2; + } + } while (true); + + this_END_9=(Token)match(input,RULE_END,FOLLOW_9); + + newLeafNode(this_END_9, grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3()); + + + } + break; + + } + + // InternalRos1Parser.g:164:3: (otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket )? + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==Dependencies) ) { + alt5=1; + } + switch (alt5) { + case 1 : + // InternalRos1Parser.g:165:4: otherlv_10= Dependencies otherlv_11= LeftSquareBracket ( (lv_dependency_12_0= ruleDependency ) ) (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* otherlv_15= RightSquareBracket + { + otherlv_10=(Token)match(input,Dependencies,FOLLOW_10); + + newLeafNode(otherlv_10, grammarAccess.getCatkinPackageAccess().getDependenciesKeyword_6_0()); + + otherlv_11=(Token)match(input,LeftSquareBracket,FOLLOW_11); + + newLeafNode(otherlv_11, grammarAccess.getCatkinPackageAccess().getLeftSquareBracketKeyword_6_1()); + + // InternalRos1Parser.g:173:4: ( (lv_dependency_12_0= ruleDependency ) ) + // InternalRos1Parser.g:174:5: (lv_dependency_12_0= ruleDependency ) + { + // InternalRos1Parser.g:174:5: (lv_dependency_12_0= ruleDependency ) + // InternalRos1Parser.g:175:6: lv_dependency_12_0= ruleDependency + { + + newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_2_0()); + + pushFollow(FOLLOW_12); + lv_dependency_12_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + current, + "dependency", + lv_dependency_12_0, + "de.fraunhofer.ipa.ros1.Ros1.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalRos1Parser.g:192:4: (otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==Comma) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalRos1Parser.g:193:5: otherlv_13= Comma ( (lv_dependency_14_0= ruleDependency ) ) + { + otherlv_13=(Token)match(input,Comma,FOLLOW_11); + + newLeafNode(otherlv_13, grammarAccess.getCatkinPackageAccess().getCommaKeyword_6_3_0()); + + // InternalRos1Parser.g:197:5: ( (lv_dependency_14_0= ruleDependency ) ) + // InternalRos1Parser.g:198:6: (lv_dependency_14_0= ruleDependency ) + { + // InternalRos1Parser.g:198:6: (lv_dependency_14_0= ruleDependency ) + // InternalRos1Parser.g:199:7: lv_dependency_14_0= ruleDependency + { + + newCompositeNode(grammarAccess.getCatkinPackageAccess().getDependencyDependencyParserRuleCall_6_3_1_0()); + + pushFollow(FOLLOW_12); + lv_dependency_14_0=ruleDependency(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getCatkinPackageRule()); + } + add( + current, + "dependency", + lv_dependency_14_0, + "de.fraunhofer.ipa.ros1.Ros1.Dependency"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop4; + } + } while (true); + + otherlv_15=(Token)match(input,RightSquareBracket,FOLLOW_13); + + newLeafNode(otherlv_15, grammarAccess.getCatkinPackageAccess().getRightSquareBracketKeyword_6_4()); + + + } + break; + + } + + this_END_16=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_16, grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleCatkinPackage" + + + // $ANTLR start "entryRuleArtifact" + // InternalRos1Parser.g:230:1: entryRuleArtifact returns [EObject current=null] : iv_ruleArtifact= ruleArtifact EOF ; + public final EObject entryRuleArtifact() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArtifact = null; + + + try { + // InternalRos1Parser.g:230:49: (iv_ruleArtifact= ruleArtifact EOF ) + // InternalRos1Parser.g:231:2: iv_ruleArtifact= ruleArtifact EOF + { + newCompositeNode(grammarAccess.getArtifactRule()); + pushFollow(FOLLOW_1); + iv_ruleArtifact=ruleArtifact(); + + state._fsp--; + + current =iv_ruleArtifact; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArtifact" + + + // $ANTLR start "ruleArtifact" + // InternalRos1Parser.g:237:1: ruleArtifact returns [EObject current=null] : ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) ; + public final EObject ruleArtifact() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token this_END_5=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_node_4_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:243:2: ( ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) ) + // InternalRos1Parser.g:244:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + { + // InternalRos1Parser.g:244:2: ( () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END ) + // InternalRos1Parser.g:245:3: () ( (lv_name_1_0= ruleRosNames ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN ( (lv_node_4_0= ruleNode ) )? this_END_5= RULE_END + { + // InternalRos1Parser.g:245:3: () + // InternalRos1Parser.g:246:4: + { + + current = forceCreateModelElement( + grammarAccess.getArtifactAccess().getArtifactAction_0(), + current); + + + } + + // InternalRos1Parser.g:252:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:253:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:253:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:254:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getArtifactAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getArtifactAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_14); + + newLeafNode(this_BEGIN_3, grammarAccess.getArtifactAccess().getBEGINTerminalRuleCall_3()); + + // InternalRos1Parser.g:279:3: ( (lv_node_4_0= ruleNode ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==Node_1) ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalRos1Parser.g:280:4: (lv_node_4_0= ruleNode ) + { + // InternalRos1Parser.g:280:4: (lv_node_4_0= ruleNode ) + // InternalRos1Parser.g:281:5: lv_node_4_0= ruleNode + { + + newCompositeNode(grammarAccess.getArtifactAccess().getNodeNodeParserRuleCall_4_0()); + + pushFollow(FOLLOW_13); + lv_node_4_0=ruleNode(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getArtifactRule()); + } + set( + current, + "node", + lv_node_4_0, + "de.fraunhofer.ipa.ros1.Ros1.Node"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + this_END_5=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_5, grammarAccess.getArtifactAccess().getENDTerminalRuleCall_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArtifact" + + + // $ANTLR start "entryRuleNode" + // InternalRos1Parser.g:306:1: entryRuleNode returns [EObject current=null] : iv_ruleNode= ruleNode EOF ; + public final EObject entryRuleNode() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNode = null; + + + try { + // InternalRos1Parser.g:306:45: (iv_ruleNode= ruleNode EOF ) + // InternalRos1Parser.g:307:2: iv_ruleNode= ruleNode EOF + { + newCompositeNode(grammarAccess.getNodeRule()); + pushFollow(FOLLOW_1); + iv_ruleNode=ruleNode(); + + state._fsp--; + + current =iv_ruleNode; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNode" + + + // $ANTLR start "ruleNode" + // InternalRos1Parser.g:313:1: ruleNode returns [EObject current=null] : (otherlv_0= Node_1 ( (lv_name_1_0= ruleRosNames ) ) this_BEGIN_2= RULE_BEGIN (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? this_END_15= RULE_END ) ; + public final EObject ruleNode() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token this_BEGIN_2=null; + Token otherlv_3=null; + Token this_BEGIN_4=null; + Token this_END_6=null; + Token otherlv_7=null; + Token this_BEGIN_8=null; + Token this_END_10=null; + Token otherlv_11=null; + Token this_BEGIN_12=null; + Token this_END_14=null; + Token this_END_15=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_publisher_5_0 = null; + + EObject lv_subscriber_9_0 = null; + + EObject lv_parameter_13_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:319:2: ( (otherlv_0= Node_1 ( (lv_name_1_0= ruleRosNames ) ) this_BEGIN_2= RULE_BEGIN (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? this_END_15= RULE_END ) ) + // InternalRos1Parser.g:320:2: (otherlv_0= Node_1 ( (lv_name_1_0= ruleRosNames ) ) this_BEGIN_2= RULE_BEGIN (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? this_END_15= RULE_END ) + { + // InternalRos1Parser.g:320:2: (otherlv_0= Node_1 ( (lv_name_1_0= ruleRosNames ) ) this_BEGIN_2= RULE_BEGIN (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? this_END_15= RULE_END ) + // InternalRos1Parser.g:321:3: otherlv_0= Node_1 ( (lv_name_1_0= ruleRosNames ) ) this_BEGIN_2= RULE_BEGIN (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? this_END_15= RULE_END + { + otherlv_0=(Token)match(input,Node_1,FOLLOW_15); + + newLeafNode(otherlv_0, grammarAccess.getNodeAccess().getNodeKeyword_0()); + + // InternalRos1Parser.g:325:3: ( (lv_name_1_0= ruleRosNames ) ) + // InternalRos1Parser.g:326:4: (lv_name_1_0= ruleRosNames ) + { + // InternalRos1Parser.g:326:4: (lv_name_1_0= ruleRosNames ) + // InternalRos1Parser.g:327:5: lv_name_1_0= ruleRosNames + { + + newCompositeNode(grammarAccess.getNodeAccess().getNameRosNamesParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleRosNames(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.RosNames"); + afterParserOrEnumRuleCall(); + + + } + + + } + + this_BEGIN_2=(Token)match(input,RULE_BEGIN,FOLLOW_16); + + newLeafNode(this_BEGIN_2, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_2()); + + // InternalRos1Parser.g:348:3: (otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==Publishers) ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalRos1Parser.g:349:4: otherlv_3= Publishers this_BEGIN_4= RULE_BEGIN ( (lv_publisher_5_0= rulePublisher ) )* this_END_6= RULE_END + { + otherlv_3=(Token)match(input,Publishers,FOLLOW_4); + + newLeafNode(otherlv_3, grammarAccess.getNodeAccess().getPublishersKeyword_3_0()); + + this_BEGIN_4=(Token)match(input,RULE_BEGIN,FOLLOW_17); + + newLeafNode(this_BEGIN_4, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()); + + // InternalRos1Parser.g:357:4: ( (lv_publisher_5_0= rulePublisher ) )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==RULE_ID||LA7_0==RULE_STRING) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalRos1Parser.g:358:5: (lv_publisher_5_0= rulePublisher ) + { + // InternalRos1Parser.g:358:5: (lv_publisher_5_0= rulePublisher ) + // InternalRos1Parser.g:359:6: lv_publisher_5_0= rulePublisher + { + + newCompositeNode(grammarAccess.getNodeAccess().getPublisherPublisherParserRuleCall_3_2_0()); + + pushFollow(FOLLOW_17); + lv_publisher_5_0=rulePublisher(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "publisher", + lv_publisher_5_0, + "de.fraunhofer.ipa.ros1.Ros1.Publisher"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop7; + } + } while (true); + + this_END_6=(Token)match(input,RULE_END,FOLLOW_18); + + newLeafNode(this_END_6, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3()); + + + } + break; + + } + + // InternalRos1Parser.g:381:3: (otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END )? + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==Subscribers) ) { + alt10=1; + } + switch (alt10) { + case 1 : + // InternalRos1Parser.g:382:4: otherlv_7= Subscribers this_BEGIN_8= RULE_BEGIN ( (lv_subscriber_9_0= ruleSubscriber ) )* this_END_10= RULE_END + { + otherlv_7=(Token)match(input,Subscribers,FOLLOW_4); + + newLeafNode(otherlv_7, grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()); + + this_BEGIN_8=(Token)match(input,RULE_BEGIN,FOLLOW_17); + + newLeafNode(this_BEGIN_8, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()); + + // InternalRos1Parser.g:390:4: ( (lv_subscriber_9_0= ruleSubscriber ) )* + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==RULE_ID||LA9_0==RULE_STRING) ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // InternalRos1Parser.g:391:5: (lv_subscriber_9_0= ruleSubscriber ) + { + // InternalRos1Parser.g:391:5: (lv_subscriber_9_0= ruleSubscriber ) + // InternalRos1Parser.g:392:6: lv_subscriber_9_0= ruleSubscriber + { + + newCompositeNode(grammarAccess.getNodeAccess().getSubscriberSubscriberParserRuleCall_4_2_0()); + + pushFollow(FOLLOW_17); + lv_subscriber_9_0=ruleSubscriber(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "subscriber", + lv_subscriber_9_0, + "de.fraunhofer.ipa.ros1.Ros1.Subscriber"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop9; + } + } while (true); + + this_END_10=(Token)match(input,RULE_END,FOLLOW_19); + + newLeafNode(this_END_10, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3()); + + + } + break; + + } + + // InternalRos1Parser.g:414:3: (otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==Parameters) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // InternalRos1Parser.g:415:4: otherlv_11= Parameters this_BEGIN_12= RULE_BEGIN ( (lv_parameter_13_0= ruleParameter ) )* this_END_14= RULE_END + { + otherlv_11=(Token)match(input,Parameters,FOLLOW_4); + + newLeafNode(otherlv_11, grammarAccess.getNodeAccess().getParametersKeyword_5_0()); + + this_BEGIN_12=(Token)match(input,RULE_BEGIN,FOLLOW_17); + + newLeafNode(this_BEGIN_12, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()); + + // InternalRos1Parser.g:423:4: ( (lv_parameter_13_0= ruleParameter ) )* + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==RULE_ID||LA11_0==RULE_STRING) ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // InternalRos1Parser.g:424:5: (lv_parameter_13_0= ruleParameter ) + { + // InternalRos1Parser.g:424:5: (lv_parameter_13_0= ruleParameter ) + // InternalRos1Parser.g:425:6: lv_parameter_13_0= ruleParameter + { + + newCompositeNode(grammarAccess.getNodeAccess().getParameterParameterParserRuleCall_5_2_0()); + + pushFollow(FOLLOW_17); + lv_parameter_13_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNodeRule()); + } + add( + current, + "parameter", + lv_parameter_13_0, + "de.fraunhofer.ipa.ros1.Ros1.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop11; + } + } while (true); + + this_END_14=(Token)match(input,RULE_END,FOLLOW_13); + + newLeafNode(this_END_14, grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3()); + + + } + break; + + } + + this_END_15=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_15, grammarAccess.getNodeAccess().getENDTerminalRuleCall_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNode" + + + // $ANTLR start "entryRulePublisher" + // InternalRos1Parser.g:455:1: entryRulePublisher returns [EObject current=null] : iv_rulePublisher= rulePublisher EOF ; + public final EObject entryRulePublisher() throws RecognitionException { + EObject current = null; + + EObject iv_rulePublisher = null; + + + try { + // InternalRos1Parser.g:455:50: (iv_rulePublisher= rulePublisher EOF ) + // InternalRos1Parser.g:456:2: iv_rulePublisher= rulePublisher EOF + { + newCompositeNode(grammarAccess.getPublisherRule()); + pushFollow(FOLLOW_1); + iv_rulePublisher=rulePublisher(); + + state._fsp--; + + current =iv_rulePublisher; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePublisher" + + + // $ANTLR start "rulePublisher" + // InternalRos1Parser.g:462:1: rulePublisher returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) ; + public final EObject rulePublisher() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_END_6=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:468:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) ) + // InternalRos1Parser.g:469:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) + { + // InternalRos1Parser.g:469:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) + // InternalRos1Parser.g:470:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END + { + // InternalRos1Parser.g:470:3: () + // InternalRos1Parser.g:471:4: + { + + current = forceCreateModelElement( + grammarAccess.getPublisherAccess().getPublisherAction_0(), + current); + + + } + + // InternalRos1Parser.g:477:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:478:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:478:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:479:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPublisherRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getPublisherAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getPublisherAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getPublisherAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:508:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:509:4: ( ruleEString ) + { + // InternalRos1Parser.g:509:4: ( ruleEString ) + // InternalRos1Parser.g:510:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getPublisherRule()); + } + + + newCompositeNode(grammarAccess.getPublisherAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_13); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_6=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_6, grammarAccess.getPublisherAccess().getENDTerminalRuleCall_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePublisher" + + + // $ANTLR start "entryRuleSubscriber" + // InternalRos1Parser.g:532:1: entryRuleSubscriber returns [EObject current=null] : iv_ruleSubscriber= ruleSubscriber EOF ; + public final EObject entryRuleSubscriber() throws RecognitionException { + EObject current = null; + + EObject iv_ruleSubscriber = null; + + + try { + // InternalRos1Parser.g:532:51: (iv_ruleSubscriber= ruleSubscriber EOF ) + // InternalRos1Parser.g:533:2: iv_ruleSubscriber= ruleSubscriber EOF + { + newCompositeNode(grammarAccess.getSubscriberRule()); + pushFollow(FOLLOW_1); + iv_ruleSubscriber=ruleSubscriber(); + + state._fsp--; + + current =iv_ruleSubscriber; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleSubscriber" + + + // $ANTLR start "ruleSubscriber" + // InternalRos1Parser.g:539:1: ruleSubscriber returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) ; + public final EObject ruleSubscriber() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token otherlv_4=null; + Token this_END_6=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:545:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) ) + // InternalRos1Parser.g:546:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) + { + // InternalRos1Parser.g:546:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END ) + // InternalRos1Parser.g:547:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN otherlv_4= Type ( ( ruleEString ) ) this_END_6= RULE_END + { + // InternalRos1Parser.g:547:3: () + // InternalRos1Parser.g:548:4: + { + + current = forceCreateModelElement( + grammarAccess.getSubscriberAccess().getSubscriberAction_0(), + current); + + + } + + // InternalRos1Parser.g:554:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:555:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:555:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:556:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getSubscriberRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getSubscriberAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_20); + + newLeafNode(this_BEGIN_3, grammarAccess.getSubscriberAccess().getBEGINTerminalRuleCall_3()); + + otherlv_4=(Token)match(input,Type,FOLLOW_6); + + newLeafNode(otherlv_4, grammarAccess.getSubscriberAccess().getTypeKeyword_4()); + + // InternalRos1Parser.g:585:3: ( ( ruleEString ) ) + // InternalRos1Parser.g:586:4: ( ruleEString ) + { + // InternalRos1Parser.g:586:4: ( ruleEString ) + // InternalRos1Parser.g:587:5: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getSubscriberRule()); + } + + + newCompositeNode(grammarAccess.getSubscriberAccess().getMessageTopicSpecCrossReference_5_0()); + + pushFollow(FOLLOW_13); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + this_END_6=(Token)match(input,RULE_END,FOLLOW_2); + + newLeafNode(this_END_6, grammarAccess.getSubscriberAccess().getENDTerminalRuleCall_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSubscriber" + + + // $ANTLR start "entryRuleParameter" + // InternalRos1Parser.g:609:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + public final EObject entryRuleParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameter = null; + + + try { + // InternalRos1Parser.g:609:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalRos1Parser.g:610:2: iv_ruleParameter= ruleParameter EOF + { + newCompositeNode(grammarAccess.getParameterRule()); + pushFollow(FOLLOW_1); + iv_ruleParameter=ruleParameter(); + + state._fsp--; + + current =iv_ruleParameter; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalRos1Parser.g:616:1: ruleParameter returns [EObject current=null] : ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN this_END_4= RULE_END otherlv_5= RightCurlyBracket ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token this_BEGIN_3=null; + Token this_END_4=null; + Token otherlv_5=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:622:2: ( ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN this_END_4= RULE_END otherlv_5= RightCurlyBracket ) ) + // InternalRos1Parser.g:623:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN this_END_4= RULE_END otherlv_5= RightCurlyBracket ) + { + // InternalRos1Parser.g:623:2: ( () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN this_END_4= RULE_END otherlv_5= RightCurlyBracket ) + // InternalRos1Parser.g:624:3: () ( (lv_name_1_0= ruleEString ) ) otherlv_2= Colon this_BEGIN_3= RULE_BEGIN this_END_4= RULE_END otherlv_5= RightCurlyBracket + { + // InternalRos1Parser.g:624:3: () + // InternalRos1Parser.g:625:4: + { + + current = forceCreateModelElement( + grammarAccess.getParameterAccess().getParameterAction_0(), + current); + + + } + + // InternalRos1Parser.g:631:3: ( (lv_name_1_0= ruleEString ) ) + // InternalRos1Parser.g:632:4: (lv_name_1_0= ruleEString ) + { + // InternalRos1Parser.g:632:4: (lv_name_1_0= ruleEString ) + // InternalRos1Parser.g:633:5: lv_name_1_0= ruleEString + { + + newCompositeNode(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0()); + + pushFollow(FOLLOW_3); + lv_name_1_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "de.fraunhofer.ipa.ros1.Ros1.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,Colon,FOLLOW_4); + + newLeafNode(otherlv_2, grammarAccess.getParameterAccess().getColonKeyword_2()); + + this_BEGIN_3=(Token)match(input,RULE_BEGIN,FOLLOW_13); + + newLeafNode(this_BEGIN_3, grammarAccess.getParameterAccess().getBEGINTerminalRuleCall_3()); + + this_END_4=(Token)match(input,RULE_END,FOLLOW_21); + + newLeafNode(this_END_4, grammarAccess.getParameterAccess().getENDTerminalRuleCall_4()); + + otherlv_5=(Token)match(input,RightCurlyBracket,FOLLOW_2); + + newLeafNode(otherlv_5, grammarAccess.getParameterAccess().getRightCurlyBracketKeyword_5()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleDependency" + // InternalRos1Parser.g:670:1: entryRuleDependency returns [EObject current=null] : iv_ruleDependency= ruleDependency EOF ; + public final EObject entryRuleDependency() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDependency = null; + + + try { + // InternalRos1Parser.g:670:51: (iv_ruleDependency= ruleDependency EOF ) + // InternalRos1Parser.g:671:2: iv_ruleDependency= ruleDependency EOF + { + newCompositeNode(grammarAccess.getDependencyRule()); + pushFollow(FOLLOW_1); + iv_ruleDependency=ruleDependency(); + + state._fsp--; + + current =iv_ruleDependency; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDependency" + + + // $ANTLR start "ruleDependency" + // InternalRos1Parser.g:677:1: ruleDependency returns [EObject current=null] : (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ; + public final EObject ruleDependency() throws RecognitionException { + EObject current = null; + + EObject this_PackageDependency_0 = null; + + EObject this_ExternalDependency_1 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:683:2: ( (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) ) + // InternalRos1Parser.g:684:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + { + // InternalRos1Parser.g:684:2: (this_PackageDependency_0= rulePackageDependency | this_ExternalDependency_1= ruleExternalDependency ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==RULE_ID||LA13_0==RULE_STRING) ) { + alt13=1; + } + else if ( (LA13_0==ExternalDependency) ) { + alt13=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // InternalRos1Parser.g:685:3: this_PackageDependency_0= rulePackageDependency + { + + newCompositeNode(grammarAccess.getDependencyAccess().getPackageDependencyParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_PackageDependency_0=rulePackageDependency(); + + state._fsp--; + + + current = this_PackageDependency_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalRos1Parser.g:694:3: this_ExternalDependency_1= ruleExternalDependency + { + + newCompositeNode(grammarAccess.getDependencyAccess().getExternalDependencyParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ExternalDependency_1=ruleExternalDependency(); + + state._fsp--; + + + current = this_ExternalDependency_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDependency" + + + // $ANTLR start "entryRulePackageDependency" + // InternalRos1Parser.g:706:1: entryRulePackageDependency returns [EObject current=null] : iv_rulePackageDependency= rulePackageDependency EOF ; + public final EObject entryRulePackageDependency() throws RecognitionException { + EObject current = null; + + EObject iv_rulePackageDependency = null; + + + try { + // InternalRos1Parser.g:706:58: (iv_rulePackageDependency= rulePackageDependency EOF ) + // InternalRos1Parser.g:707:2: iv_rulePackageDependency= rulePackageDependency EOF + { + newCompositeNode(grammarAccess.getPackageDependencyRule()); + pushFollow(FOLLOW_1); + iv_rulePackageDependency=rulePackageDependency(); + + state._fsp--; + + current =iv_rulePackageDependency; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePackageDependency" + + + // $ANTLR start "rulePackageDependency" + // InternalRos1Parser.g:713:1: rulePackageDependency returns [EObject current=null] : ( ( ruleEString ) ) ; + public final EObject rulePackageDependency() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalRos1Parser.g:719:2: ( ( ( ruleEString ) ) ) + // InternalRos1Parser.g:720:2: ( ( ruleEString ) ) + { + // InternalRos1Parser.g:720:2: ( ( ruleEString ) ) + // InternalRos1Parser.g:721:3: ( ruleEString ) + { + // InternalRos1Parser.g:721:3: ( ruleEString ) + // InternalRos1Parser.g:722:4: ruleEString + { + + if (current==null) { + current = createModelElement(grammarAccess.getPackageDependencyRule()); + } + + + newCompositeNode(grammarAccess.getPackageDependencyAccess().getPackagePackageCrossReference_0()); + + pushFollow(FOLLOW_2); + ruleEString(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePackageDependency" + + + // $ANTLR start "entryRuleExternalDependency" + // InternalRos1Parser.g:739:1: entryRuleExternalDependency returns [EObject current=null] : iv_ruleExternalDependency= ruleExternalDependency EOF ; + public final EObject entryRuleExternalDependency() throws RecognitionException { + EObject current = null; + + EObject iv_ruleExternalDependency = null; + + + try { + // InternalRos1Parser.g:739:59: (iv_ruleExternalDependency= ruleExternalDependency EOF ) + // InternalRos1Parser.g:740:2: iv_ruleExternalDependency= ruleExternalDependency EOF + { + newCompositeNode(grammarAccess.getExternalDependencyRule()); + pushFollow(FOLLOW_1); + iv_ruleExternalDependency=ruleExternalDependency(); + + state._fsp--; + + current =iv_ruleExternalDependency; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleExternalDependency" + + + // $ANTLR start "ruleExternalDependency" + // InternalRos1Parser.g:746:1: ruleExternalDependency returns [EObject current=null] : ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) ; + public final EObject ruleExternalDependency() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + + + enterRule(); + + try { + // InternalRos1Parser.g:752:2: ( ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) ) + // InternalRos1Parser.g:753:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + { + // InternalRos1Parser.g:753:2: ( () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) ) + // InternalRos1Parser.g:754:3: () otherlv_1= ExternalDependency ( (lv_name_2_0= ruleEString ) ) + { + // InternalRos1Parser.g:754:3: () + // InternalRos1Parser.g:755:4: + { + + current = forceCreateModelElement( + grammarAccess.getExternalDependencyAccess().getExternalDependencyAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,ExternalDependency,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getExternalDependencyAccess().getExternalDependencyKeyword_1()); + + // InternalRos1Parser.g:765:3: ( (lv_name_2_0= ruleEString ) ) + // InternalRos1Parser.g:766:4: (lv_name_2_0= ruleEString ) + { + // InternalRos1Parser.g:766:4: (lv_name_2_0= ruleEString ) + // InternalRos1Parser.g:767:5: lv_name_2_0= ruleEString + { + + newCompositeNode(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0()); + + pushFollow(FOLLOW_2); + lv_name_2_0=ruleEString(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getExternalDependencyRule()); + } + set( + current, + "name", + lv_name_2_0, + "de.fraunhofer.ipa.ros1.Ros1.EString"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleExternalDependency" + + + // $ANTLR start "entryRuleRosNames" + // InternalRos1Parser.g:788:1: entryRuleRosNames returns [String current=null] : iv_ruleRosNames= ruleRosNames EOF ; + public final String entryRuleRosNames() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleRosNames = null; + + + try { + // InternalRos1Parser.g:788:48: (iv_ruleRosNames= ruleRosNames EOF ) + // InternalRos1Parser.g:789:2: iv_ruleRosNames= ruleRosNames EOF + { + newCompositeNode(grammarAccess.getRosNamesRule()); + pushFollow(FOLLOW_1); + iv_ruleRosNames=ruleRosNames(); + + state._fsp--; + + current =iv_ruleRosNames.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRosNames" + + + // $ANTLR start "ruleRosNames" + // InternalRos1Parser.g:795:1: ruleRosNames returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) ; + public final AntlrDatatypeRuleToken ruleRosNames() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ROS_CONVENTION_A_0=null; + Token this_ID_1=null; + Token kw=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:801:2: ( (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) ) + // InternalRos1Parser.g:802:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + { + // InternalRos1Parser.g:802:2: (this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A | this_ID_1= RULE_ID | kw= Node ) + int alt14=3; + switch ( input.LA(1) ) { + case RULE_ROS_CONVENTION_A: + { + alt14=1; + } + break; + case RULE_ID: + { + alt14=2; + } + break; + case Node: + { + alt14=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalRos1Parser.g:803:3: this_ROS_CONVENTION_A_0= RULE_ROS_CONVENTION_A + { + this_ROS_CONVENTION_A_0=(Token)match(input,RULE_ROS_CONVENTION_A,FOLLOW_2); + + current.merge(this_ROS_CONVENTION_A_0); + + + newLeafNode(this_ROS_CONVENTION_A_0, grammarAccess.getRosNamesAccess().getROS_CONVENTION_ATerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalRos1Parser.g:811:3: this_ID_1= RULE_ID + { + this_ID_1=(Token)match(input,RULE_ID,FOLLOW_2); + + current.merge(this_ID_1); + + + newLeafNode(this_ID_1, grammarAccess.getRosNamesAccess().getIDTerminalRuleCall_1()); + + + } + break; + case 3 : + // InternalRos1Parser.g:819:3: kw= Node + { + kw=(Token)match(input,Node,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getRosNamesAccess().getNodeKeyword_2()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRosNames" + + + // $ANTLR start "entryRuleEString" + // InternalRos1Parser.g:828:1: entryRuleEString returns [String current=null] : iv_ruleEString= ruleEString EOF ; + public final String entryRuleEString() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleEString = null; + + + try { + // InternalRos1Parser.g:828:47: (iv_ruleEString= ruleEString EOF ) + // InternalRos1Parser.g:829:2: iv_ruleEString= ruleEString EOF + { + newCompositeNode(grammarAccess.getEStringRule()); + pushFollow(FOLLOW_1); + iv_ruleEString=ruleEString(); + + state._fsp--; + + current =iv_ruleEString.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEString" + + + // $ANTLR start "ruleEString" + // InternalRos1Parser.g:835:1: ruleEString returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ; + public final AntlrDatatypeRuleToken ruleEString() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_STRING_0=null; + Token this_ID_1=null; + + + enterRule(); + + try { + // InternalRos1Parser.g:841:2: ( (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) ) + // InternalRos1Parser.g:842:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + { + // InternalRos1Parser.g:842:2: (this_STRING_0= RULE_STRING | this_ID_1= RULE_ID ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==RULE_STRING) ) { + alt15=1; + } + else if ( (LA15_0==RULE_ID) ) { + alt15=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalRos1Parser.g:843:3: this_STRING_0= RULE_STRING + { + this_STRING_0=(Token)match(input,RULE_STRING,FOLLOW_2); + + current.merge(this_STRING_0); + + + newLeafNode(this_STRING_0, grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalRos1Parser.g:851:3: this_ID_1= RULE_ID + { + this_ID_1=(Token)match(input,RULE_ID,FOLLOW_2); + + current.merge(this_ID_1); + + + newLeafNode(this_ID_1, grammarAccess.getEStringAccess().getIDTerminalRuleCall_1()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEString" + + // Delegated rules + + + + + 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[]{0x0000000000008000L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000080000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000100460L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000001400000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000100420L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000D02000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000100020L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000001400010L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000024000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000100000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000100800L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000C02000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000100380L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000001500000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000100180L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000100100L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000001000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000040000L}); + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens new file mode 100644 index 000000000..aec474468 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/internal/InternalRos1Parser.tokens @@ -0,0 +1,26 @@ +','=14 +':'=15 +'ExternalDependency'=4 +'['=16 +']'=17 +'artifacts:'=10 +'dependencies:'=5 +'fromGitRepo:'=6 +'node'=13 +'node:'=11 +'parameters:'=8 +'publishers:'=9 +'subscribers:'=7 +'type:'=12 +'}'=18 +RULE_ANY_OTHER=29 +RULE_BEGIN=19 +RULE_END=20 +RULE_ID=22 +RULE_INT=26 +RULE_ML_COMMENT=27 +RULE_ROS_CONVENTION_A=23 +RULE_ROS_CONVENTION_PARAM=25 +RULE_SL_COMMENT=21 +RULE_STRING=24 +RULE_WS=28 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.g b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.g new file mode 100644 index 000000000..8cf4f0ce4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.g @@ -0,0 +1,64 @@ +/* + * generated by Xtext 2.25.0 + */ +lexer grammar InternalRos1Lexer; + +@header { +package de.fraunhofer.ipa.ros1.parser.antlr.lexer; + +// 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; +} + +ExternalDependency : 'ExternalDependency'; + +Dependencies : 'dependencies:'; + +FromGitRepo : 'fromGitRepo:'; + +Subscribers : 'subscribers:'; + +Parameters : 'parameters:'; + +Publishers : 'publishers:'; + +Artifacts : 'artifacts:'; + +Node_1 : 'node:'; + +Type : 'type:'; + +Node : 'node'; + +Comma : ','; + +Colon : ':'; + +LeftSquareBracket : '['; + +RightSquareBracket : ']'; + +RightCurlyBracket : '}'; + +fragment RULE_BEGIN : ; + +fragment RULE_END : ; + +RULE_SL_COMMENT : '#' ~(('\n'|'\r'))*; + +RULE_ROS_CONVENTION_A : ('/' RULE_ID|RULE_ID '/')*; + +RULE_ROS_CONVENTION_PARAM : ('/' RULE_STRING|RULE_STRING '/'|'~' RULE_STRING)*; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +RULE_INT : ('0'..'9')+; + +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.java new file mode 100644 index 000000000..b22615cf4 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.java @@ -0,0 +1,1508 @@ +package de.fraunhofer.ipa.ros1.parser.antlr.lexer; + +// 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 InternalRos1Lexer extends Lexer { + public static final int RULE_END=20; + public static final int RULE_BEGIN=19; + public static final int Node=13; + public static final int RULE_STRING=24; + public static final int RULE_SL_COMMENT=21; + public static final int Comma=14; + public static final int RULE_ROS_CONVENTION_A=23; + public static final int Publishers=9; + public static final int RULE_ROS_CONVENTION_PARAM=25; + public static final int Dependencies=5; + public static final int Colon=15; + public static final int RightCurlyBracket=18; + public static final int EOF=-1; + public static final int RightSquareBracket=17; + public static final int FromGitRepo=6; + public static final int ExternalDependency=4; + public static final int Parameters=8; + public static final int RULE_ID=22; + public static final int RULE_WS=28; + public static final int RULE_ANY_OTHER=29; + public static final int Artifacts=10; + public static final int Node_1=11; + public static final int Type=12; + public static final int RULE_INT=26; + public static final int RULE_ML_COMMENT=27; + public static final int LeftSquareBracket=16; + public static final int Subscribers=7; + + // delegates + // delegators + + public InternalRos1Lexer() {;} + public InternalRos1Lexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalRos1Lexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalRos1Lexer.g"; } + + // $ANTLR start "ExternalDependency" + public final void mExternalDependency() throws RecognitionException { + try { + int _type = ExternalDependency; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:14:20: ( 'ExternalDependency' ) + // InternalRos1Lexer.g:14:22: 'ExternalDependency' + { + match("ExternalDependency"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "ExternalDependency" + + // $ANTLR start "Dependencies" + public final void mDependencies() throws RecognitionException { + try { + int _type = Dependencies; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:16:14: ( 'dependencies:' ) + // InternalRos1Lexer.g:16:16: 'dependencies:' + { + match("dependencies:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Dependencies" + + // $ANTLR start "FromGitRepo" + public final void mFromGitRepo() throws RecognitionException { + try { + int _type = FromGitRepo; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:18:13: ( 'fromGitRepo:' ) + // InternalRos1Lexer.g:18:15: 'fromGitRepo:' + { + match("fromGitRepo:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "FromGitRepo" + + // $ANTLR start "Subscribers" + public final void mSubscribers() throws RecognitionException { + try { + int _type = Subscribers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:20:13: ( 'subscribers:' ) + // InternalRos1Lexer.g:20:15: 'subscribers:' + { + match("subscribers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Subscribers" + + // $ANTLR start "Parameters" + public final void mParameters() throws RecognitionException { + try { + int _type = Parameters; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:22:12: ( 'parameters:' ) + // InternalRos1Lexer.g:22:14: 'parameters:' + { + match("parameters:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Parameters" + + // $ANTLR start "Publishers" + public final void mPublishers() throws RecognitionException { + try { + int _type = Publishers; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:24:12: ( 'publishers:' ) + // InternalRos1Lexer.g:24:14: 'publishers:' + { + match("publishers:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Publishers" + + // $ANTLR start "Artifacts" + public final void mArtifacts() throws RecognitionException { + try { + int _type = Artifacts; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:26:11: ( 'artifacts:' ) + // InternalRos1Lexer.g:26:13: 'artifacts:' + { + match("artifacts:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Artifacts" + + // $ANTLR start "Node_1" + public final void mNode_1() throws RecognitionException { + try { + int _type = Node_1; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:28:8: ( 'node:' ) + // InternalRos1Lexer.g:28:10: 'node:' + { + match("node:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node_1" + + // $ANTLR start "Type" + public final void mType() throws RecognitionException { + try { + int _type = Type; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:30:6: ( 'type:' ) + // InternalRos1Lexer.g:30:8: 'type:' + { + match("type:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Type" + + // $ANTLR start "Node" + public final void mNode() throws RecognitionException { + try { + int _type = Node; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:32:6: ( 'node' ) + // InternalRos1Lexer.g:32:8: 'node' + { + match("node"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Node" + + // $ANTLR start "Comma" + public final void mComma() throws RecognitionException { + try { + int _type = Comma; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:34:7: ( ',' ) + // InternalRos1Lexer.g:34:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Comma" + + // $ANTLR start "Colon" + public final void mColon() throws RecognitionException { + try { + int _type = Colon; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:36:7: ( ':' ) + // InternalRos1Lexer.g:36:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "Colon" + + // $ANTLR start "LeftSquareBracket" + public final void mLeftSquareBracket() throws RecognitionException { + try { + int _type = LeftSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:38:19: ( '[' ) + // InternalRos1Lexer.g:38:21: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "LeftSquareBracket" + + // $ANTLR start "RightSquareBracket" + public final void mRightSquareBracket() throws RecognitionException { + try { + int _type = RightSquareBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:40:20: ( ']' ) + // InternalRos1Lexer.g:40:22: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightSquareBracket" + + // $ANTLR start "RightCurlyBracket" + public final void mRightCurlyBracket() throws RecognitionException { + try { + int _type = RightCurlyBracket; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:42:19: ( '}' ) + // InternalRos1Lexer.g:42:21: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RightCurlyBracket" + + // $ANTLR start "RULE_BEGIN" + public final void mRULE_BEGIN() throws RecognitionException { + try { + // InternalRos1Lexer.g:44:21: () + // InternalRos1Lexer.g:44:23: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_BEGIN" + + // $ANTLR start "RULE_END" + public final void mRULE_END() throws RecognitionException { + try { + // InternalRos1Lexer.g:46:19: () + // InternalRos1Lexer.g:46:21: + { + } + + } + finally { + } + } + // $ANTLR end "RULE_END" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:48:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ) + // InternalRos1Lexer.g:48:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* + { + match('#'); + // InternalRos1Lexer.g:48:23: (~ ( ( '\\n' | '\\r' ) ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalRos1Lexer.g:48:23: ~ ( ( '\\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 loop1; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_ROS_CONVENTION_A" + public final void mRULE_ROS_CONVENTION_A() throws RecognitionException { + try { + int _type = RULE_ROS_CONVENTION_A; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:50:23: ( ( '/' RULE_ID | RULE_ID '/' )* ) + // InternalRos1Lexer.g:50:25: ( '/' RULE_ID | RULE_ID '/' )* + { + // InternalRos1Lexer.g:50:25: ( '/' RULE_ID | RULE_ID '/' )* + loop2: + do { + int alt2=3; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='/') ) { + alt2=1; + } + else if ( ((LA2_0>='A' && LA2_0<='Z')||(LA2_0>='^' && LA2_0<='_')||(LA2_0>='a' && LA2_0<='z')) ) { + alt2=2; + } + + + switch (alt2) { + case 1 : + // InternalRos1Lexer.g:50:26: '/' RULE_ID + { + match('/'); + mRULE_ID(); + + } + break; + case 2 : + // InternalRos1Lexer.g:50:38: RULE_ID '/' + { + mRULE_ID(); + match('/'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ROS_CONVENTION_A" + + // $ANTLR start "RULE_ROS_CONVENTION_PARAM" + public final void mRULE_ROS_CONVENTION_PARAM() throws RecognitionException { + try { + int _type = RULE_ROS_CONVENTION_PARAM; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:52:27: ( ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* ) + // InternalRos1Lexer.g:52:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + { + // InternalRos1Lexer.g:52:29: ( '/' RULE_STRING | RULE_STRING '/' | '~' RULE_STRING )* + loop3: + do { + int alt3=4; + switch ( input.LA(1) ) { + case '/': + { + alt3=1; + } + break; + case '\"': + case '\'': + { + alt3=2; + } + break; + case '~': + { + alt3=3; + } + break; + + } + + switch (alt3) { + case 1 : + // InternalRos1Lexer.g:52:30: '/' RULE_STRING + { + match('/'); + mRULE_STRING(); + + } + break; + case 2 : + // InternalRos1Lexer.g:52:46: RULE_STRING '/' + { + mRULE_STRING(); + match('/'); + + } + break; + case 3 : + // InternalRos1Lexer.g:52:62: '~' RULE_STRING + { + match('~'); + mRULE_STRING(); + + } + break; + + default : + break loop3; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ROS_CONVENTION_PARAM" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:54:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalRos1Lexer.g:54:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalRos1Lexer.g:54:11: ( '^' )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0=='^') ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalRos1Lexer.g:54:11: '^' + { + match('^'); + + } + break; + + } + + if ( (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;} + + // InternalRos1Lexer.g:54:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='9')||(LA5_0>='A' && LA5_0<='Z')||LA5_0=='_'||(LA5_0>='a' && LA5_0<='z')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalRos1Lexer.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop5; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:56:10: ( ( '0' .. '9' )+ ) + // InternalRos1Lexer.g:56:12: ( '0' .. '9' )+ + { + // InternalRos1Lexer.g:56:12: ( '0' .. '9' )+ + int cnt6=0; + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( ((LA6_0>='0' && LA6_0<='9')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalRos1Lexer.g:56:13: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt6 >= 1 ) break loop6; + EarlyExitException eee = + new EarlyExitException(6, input); + throw eee; + } + cnt6++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:58:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) + // InternalRos1Lexer.g:58:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + { + // InternalRos1Lexer.g:58:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='\"') ) { + alt9=1; + } + else if ( (LA9_0=='\'') ) { + alt9=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // InternalRos1Lexer.g:58:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalRos1Lexer.g:58:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop7: + do { + int alt7=3; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='\\') ) { + alt7=1; + } + else if ( ((LA7_0>='\u0000' && LA7_0<='!')||(LA7_0>='#' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { + alt7=2; + } + + + switch (alt7) { + case 1 : + // InternalRos1Lexer.g:58:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:58: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 loop7; + } + } while (true); + + match('\"'); + + } + break; + case 2 : + // InternalRos1Lexer.g:58:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalRos1Lexer.g:58:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop8: + do { + int alt8=3; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='\\') ) { + alt8=1; + } + else if ( ((LA8_0>='\u0000' && LA8_0<='&')||(LA8_0>='(' && LA8_0<='[')||(LA8_0>=']' && LA8_0<='\uFFFF')) ) { + alt8=2; + } + + + switch (alt8) { + case 1 : + // InternalRos1Lexer.g:58:54: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalRos1Lexer.g:58:61: ~ ( ( '\\\\' | '\\'' ) ) + { + 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 loop8; + } + } while (true); + + match('\''); + + } + 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; + // InternalRos1Lexer.g:60:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalRos1Lexer.g:60:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalRos1Lexer.g:60:24: ( options {greedy=false; } : . )* + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='*') ) { + int LA10_1 = input.LA(2); + + if ( (LA10_1=='/') ) { + alt10=2; + } + else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { + alt10=1; + } + + + } + else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { + alt10=1; + } + + + switch (alt10) { + case 1 : + // InternalRos1Lexer.g:60:52: . + { + matchAny(); + + } + break; + + default : + break loop10; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalRos1Lexer.g:62:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalRos1Lexer.g:62:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalRos1Lexer.g:62:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt11=0; + loop11: + do { + int alt11=2; + int LA11_0 = input.LA(1); + + if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { + alt11=1; + } + + + switch (alt11) { + case 1 : + // InternalRos1Lexer.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 ( cnt11 >= 1 ) break loop11; + EarlyExitException eee = + new EarlyExitException(11, input); + throw eee; + } + cnt11++; + } 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; + // InternalRos1Lexer.g:64:16: ( . ) + // InternalRos1Lexer.g:64:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalRos1Lexer.g:1:8: ( ExternalDependency | Dependencies | FromGitRepo | Subscribers | Parameters | Publishers | Artifacts | Node_1 | Type | Node | Comma | Colon | LeftSquareBracket | RightSquareBracket | RightCurlyBracket | RULE_SL_COMMENT | RULE_ROS_CONVENTION_A | RULE_ROS_CONVENTION_PARAM | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt12=24; + alt12 = dfa12.predict(input); + switch (alt12) { + case 1 : + // InternalRos1Lexer.g:1:10: ExternalDependency + { + mExternalDependency(); + + } + break; + case 2 : + // InternalRos1Lexer.g:1:29: Dependencies + { + mDependencies(); + + } + break; + case 3 : + // InternalRos1Lexer.g:1:42: FromGitRepo + { + mFromGitRepo(); + + } + break; + case 4 : + // InternalRos1Lexer.g:1:54: Subscribers + { + mSubscribers(); + + } + break; + case 5 : + // InternalRos1Lexer.g:1:66: Parameters + { + mParameters(); + + } + break; + case 6 : + // InternalRos1Lexer.g:1:77: Publishers + { + mPublishers(); + + } + break; + case 7 : + // InternalRos1Lexer.g:1:88: Artifacts + { + mArtifacts(); + + } + break; + case 8 : + // InternalRos1Lexer.g:1:98: Node_1 + { + mNode_1(); + + } + break; + case 9 : + // InternalRos1Lexer.g:1:105: Type + { + mType(); + + } + break; + case 10 : + // InternalRos1Lexer.g:1:110: Node + { + mNode(); + + } + break; + case 11 : + // InternalRos1Lexer.g:1:115: Comma + { + mComma(); + + } + break; + case 12 : + // InternalRos1Lexer.g:1:121: Colon + { + mColon(); + + } + break; + case 13 : + // InternalRos1Lexer.g:1:127: LeftSquareBracket + { + mLeftSquareBracket(); + + } + break; + case 14 : + // InternalRos1Lexer.g:1:145: RightSquareBracket + { + mRightSquareBracket(); + + } + break; + case 15 : + // InternalRos1Lexer.g:1:164: RightCurlyBracket + { + mRightCurlyBracket(); + + } + break; + case 16 : + // InternalRos1Lexer.g:1:182: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 17 : + // InternalRos1Lexer.g:1:198: RULE_ROS_CONVENTION_A + { + mRULE_ROS_CONVENTION_A(); + + } + break; + case 18 : + // InternalRos1Lexer.g:1:220: RULE_ROS_CONVENTION_PARAM + { + mRULE_ROS_CONVENTION_PARAM(); + + } + break; + case 19 : + // InternalRos1Lexer.g:1:246: RULE_ID + { + mRULE_ID(); + + } + break; + case 20 : + // InternalRos1Lexer.g:1:254: RULE_INT + { + mRULE_INT(); + + } + break; + case 21 : + // InternalRos1Lexer.g:1:263: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 22 : + // InternalRos1Lexer.g:1:275: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 23 : + // InternalRos1Lexer.g:1:291: RULE_WS + { + mRULE_WS(); + + } + break; + case 24 : + // InternalRos1Lexer.g:1:299: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA12 dfa12 = new DFA12(this); + static final String DFA12_eotS = + "\1\22\10\32\6\uffff\2\30\1\32\1\uffff\3\30\3\uffff\1\32\1\uffff\11\32\10\uffff\1\32\2\uffff\1\77\2\uffff\1\77\2\uffff\11\32\3\uffff\7\32\1\122\10\32\3\uffff\42\32\1\uffff\4\32\2\uffff\2\32\2\uffff\1\32\1\uffff\4\32\1\u0088\1\uffff"; + static final String DFA12_eofS = + "\u0089\uffff"; + static final String DFA12_minS = + "\1\0\10\57\6\uffff\1\42\1\101\1\57\1\uffff\2\0\1\42\3\uffff\1\57\1\uffff\11\57\10\uffff\1\57\2\0\1\57\2\0\1\57\2\uffff\11\57\1\0\1\uffff\1\0\20\57\3\uffff\42\57\1\uffff\4\57\2\uffff\2\57\2\uffff\1\57\1\uffff\5\57\1\uffff"; + static final String DFA12_maxS = + "\1\uffff\10\172\6\uffff\3\172\1\uffff\2\uffff\1\47\3\uffff\1\172\1\uffff\11\172\10\uffff\1\172\2\uffff\1\57\2\uffff\1\57\2\uffff\11\172\1\uffff\1\uffff\1\uffff\20\172\3\uffff\42\172\1\uffff\4\172\2\uffff\2\172\2\uffff\1\172\1\uffff\5\172\1\uffff"; + static final String DFA12_acceptS = + "\11\uffff\1\13\1\14\1\15\1\16\1\17\1\20\3\uffff\1\21\3\uffff\1\24\1\27\1\30\1\uffff\1\23\11\uffff\1\13\1\14\1\15\1\16\1\17\1\20\1\26\1\22\7\uffff\1\24\1\27\12\uffff\1\25\21\uffff\1\10\1\12\1\11\42\uffff\1\7\4\uffff\1\5\1\6\2\uffff\1\3\1\4\1\uffff\1\2\5\uffff\1\1"; + static final String DFA12_specialS = + "\1\10\22\uffff\1\6\1\7\30\uffff\1\4\1\1\1\uffff\1\5\1\3\14\uffff\1\0\1\uffff\1\2\110\uffff}>"; + static final String[] DFA12_transitionS = { + "\11\30\2\27\2\30\1\27\22\30\1\27\1\30\1\23\1\16\3\30\1\24\4\30\1\11\2\30\1\17\12\26\1\12\6\30\4\21\1\1\25\21\1\13\1\30\1\14\1\20\1\21\1\30\1\6\2\21\1\2\1\21\1\3\7\21\1\7\1\21\1\5\2\21\1\4\1\10\6\21\2\30\1\15\1\25\uff81\30", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\27\33\1\31\2\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\34\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\35\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\24\33\1\36\5\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\37\23\33\1\40\5\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\41\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\42\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\30\33\1\43\1\33", + "", + "", + "", + "", + "", + "", + "\1\53\4\uffff\1\53\2\uffff\1\52\26\uffff\32\22\3\uffff\2\22\1\uffff\32\22", + "\32\54\4\uffff\1\54\1\uffff\32\54", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "\42\56\1\57\71\56\1\55\uffa3\56", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\53\4\uffff\1\53", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\65\6\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\66\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\67\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\70\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\71\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\72\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\73\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\74\26\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\75\12\33", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\0\76", + "\42\56\1\57\71\56\1\55\uffa3\56", + "\1\53", + "\0\100", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\53", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\101\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\102\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\14\33\1\103\15\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\104\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\105\31\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\13\33\1\106\16\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\107\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\110\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\111\25\33", + "\42\56\1\57\71\56\1\55\uffa3\56", + "", + "\47\61\1\62\64\61\1\60\uffa3\61", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\112\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\113\14\33", + "\1\22\12\33\7\uffff\6\33\1\114\23\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\115\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\14\33\1\116\15\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\117\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\5\33\1\120\24\33", + "\1\22\12\33\1\121\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\123\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\124\14\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\125\26\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\126\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\127\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\130\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\131\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\132\31\33", + "", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\133\31\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\134\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\135\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\136\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\137\6\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\7\33\1\140\22\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\141\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\13\33\1\142\16\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\143\14\33", + "\1\22\12\33\7\uffff\21\33\1\144\10\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\1\33\1\145\30\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\146\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\147\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\23\33\1\150\6\33", + "\1\22\12\33\7\uffff\3\33\1\151\26\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\152\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\153\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\154\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\155\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\156\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\157\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\160\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\10\33\1\161\21\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\162\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\21\33\1\163\10\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\164\7\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\165\7\33", + "\1\22\12\33\1\166\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\17\33\1\167\12\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\170\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\16\33\1\171\13\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\172\7\33", + "\1\22\12\33\1\173\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\174\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\175\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\22\33\1\176\7\33", + "\1\22\12\33\1\177\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "\1\22\12\33\1\u0080\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\u0081\14\33", + "\1\22\12\33\1\u0082\6\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\3\33\1\u0083\26\33", + "", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\4\33\1\u0084\25\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\15\33\1\u0085\14\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\2\33\1\u0086\27\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\30\33\1\u0087\1\33", + "\1\22\12\33\7\uffff\32\33\4\uffff\1\33\1\uffff\32\33", + "" + }; + + static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); + static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); + static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); + static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); + static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); + static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); + static final short[][] DFA12_transition; + + static { + int numStates = DFA12_transitionS.length; + DFA12_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA12_62<='!')||(LA12_62>='#' && LA12_62<='[')||(LA12_62>=']' && LA12_62<='\uFFFF')) ) {s = 46;} + + if ( s>=0 ) return s; + break; + case 1 : + int LA12_46 = input.LA(1); + + s = -1; + if ( (LA12_46=='\"') ) {s = 47;} + + else if ( (LA12_46=='\\') ) {s = 45;} + + else if ( ((LA12_46>='\u0000' && LA12_46<='!')||(LA12_46>='#' && LA12_46<='[')||(LA12_46>=']' && LA12_46<='\uFFFF')) ) {s = 46;} + + if ( s>=0 ) return s; + break; + case 2 : + int LA12_64 = input.LA(1); + + s = -1; + if ( (LA12_64=='\'') ) {s = 50;} + + else if ( (LA12_64=='\\') ) {s = 48;} + + else if ( ((LA12_64>='\u0000' && LA12_64<='&')||(LA12_64>='(' && LA12_64<='[')||(LA12_64>=']' && LA12_64<='\uFFFF')) ) {s = 49;} + + if ( s>=0 ) return s; + break; + case 3 : + int LA12_49 = input.LA(1); + + s = -1; + if ( (LA12_49=='\'') ) {s = 50;} + + else if ( (LA12_49=='\\') ) {s = 48;} + + else if ( ((LA12_49>='\u0000' && LA12_49<='&')||(LA12_49>='(' && LA12_49<='[')||(LA12_49>=']' && LA12_49<='\uFFFF')) ) {s = 49;} + + if ( s>=0 ) return s; + break; + case 4 : + int LA12_45 = input.LA(1); + + s = -1; + if ( ((LA12_45>='\u0000' && LA12_45<='\uFFFF')) ) {s = 62;} + + if ( s>=0 ) return s; + break; + case 5 : + int LA12_48 = input.LA(1); + + s = -1; + if ( ((LA12_48>='\u0000' && LA12_48<='\uFFFF')) ) {s = 64;} + + if ( s>=0 ) return s; + break; + case 6 : + int LA12_19 = input.LA(1); + + s = -1; + if ( (LA12_19=='\\') ) {s = 45;} + + else if ( ((LA12_19>='\u0000' && LA12_19<='!')||(LA12_19>='#' && LA12_19<='[')||(LA12_19>=']' && LA12_19<='\uFFFF')) ) {s = 46;} + + else if ( (LA12_19=='\"') ) {s = 47;} + + else s = 24; + + if ( s>=0 ) return s; + break; + case 7 : + int LA12_20 = input.LA(1); + + s = -1; + if ( (LA12_20=='\\') ) {s = 48;} + + else if ( ((LA12_20>='\u0000' && LA12_20<='&')||(LA12_20>='(' && LA12_20<='[')||(LA12_20>=']' && LA12_20<='\uFFFF')) ) {s = 49;} + + else if ( (LA12_20=='\'') ) {s = 50;} + + else s = 24; + + if ( s>=0 ) return s; + break; + case 8 : + int LA12_0 = input.LA(1); + + s = -1; + if ( (LA12_0=='E') ) {s = 1;} + + else if ( (LA12_0=='d') ) {s = 2;} + + else if ( (LA12_0=='f') ) {s = 3;} + + else if ( (LA12_0=='s') ) {s = 4;} + + else if ( (LA12_0=='p') ) {s = 5;} + + else if ( (LA12_0=='a') ) {s = 6;} + + else if ( (LA12_0=='n') ) {s = 7;} + + else if ( (LA12_0=='t') ) {s = 8;} + + else if ( (LA12_0==',') ) {s = 9;} + + else if ( (LA12_0==':') ) {s = 10;} + + else if ( (LA12_0=='[') ) {s = 11;} + + else if ( (LA12_0==']') ) {s = 12;} + + else if ( (LA12_0=='}') ) {s = 13;} + + else if ( (LA12_0=='#') ) {s = 14;} + + else if ( (LA12_0=='/') ) {s = 15;} + + else if ( (LA12_0=='^') ) {s = 16;} + + else if ( ((LA12_0>='A' && LA12_0<='D')||(LA12_0>='F' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='b' && LA12_0<='c')||LA12_0=='e'||(LA12_0>='g' && LA12_0<='m')||LA12_0=='o'||(LA12_0>='q' && LA12_0<='r')||(LA12_0>='u' && LA12_0<='z')) ) {s = 17;} + + else if ( (LA12_0=='\"') ) {s = 19;} + + else if ( (LA12_0=='\'') ) {s = 20;} + + else if ( (LA12_0=='~') ) {s = 21;} + + else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 22;} + + else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 23;} + + else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||LA12_0=='!'||(LA12_0>='$' && LA12_0<='&')||(LA12_0>='(' && LA12_0<='+')||(LA12_0>='-' && LA12_0<='.')||(LA12_0>=';' && LA12_0<='@')||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='{' && LA12_0<='|')||(LA12_0>='\u007F' && LA12_0<='\uFFFF')) ) {s = 24;} + + else s = 18; + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 12, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.tokens b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.tokens new file mode 100644 index 000000000..85f28ff2c --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/parser/antlr/lexer/InternalRos1Lexer.tokens @@ -0,0 +1,26 @@ +Artifacts=10 +Colon=15 +Comma=14 +Dependencies=5 +ExternalDependency=4 +FromGitRepo=6 +LeftSquareBracket=16 +Node=13 +Node_1=11 +Parameters=8 +Publishers=9 +RULE_ANY_OTHER=29 +RULE_BEGIN=19 +RULE_END=20 +RULE_ID=22 +RULE_INT=26 +RULE_ML_COMMENT=27 +RULE_ROS_CONVENTION_A=23 +RULE_ROS_CONVENTION_PARAM=25 +RULE_SL_COMMENT=21 +RULE_STRING=24 +RULE_WS=28 +RightCurlyBracket=18 +RightSquareBracket=17 +Subscribers=7 +Type=12 diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/scoping/AbstractRos1ScopeProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/scoping/AbstractRos1ScopeProvider.java new file mode 100644 index 000000000..a111bf120 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/scoping/AbstractRos1ScopeProvider.java @@ -0,0 +1,9 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.scoping; + +import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider; + +public abstract class AbstractRos1ScopeProvider extends DelegatingScopeProvider { +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SemanticSequencer.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SemanticSequencer.java new file mode 100644 index 000000000..af075577d --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SemanticSequencer.java @@ -0,0 +1,204 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.serializer; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; +import java.util.Set; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Parameter; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.serializer.ISerializationContext; +import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; +import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; +import ros.Artifact; +import ros.CatkinPackage; +import ros.ExternalDependency; +import ros.Node; +import ros.PackageDependency; +import ros.Publisher; +import ros.RosPackage; +import ros.Subscriber; + +@SuppressWarnings("all") +public class Ros1SemanticSequencer extends AbstractDelegatingSemanticSequencer { + + @Inject + private Ros1GrammarAccess 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 == RosPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case RosPackage.ARTIFACT: + sequence_Artifact(context, (Artifact) semanticObject); + return; + case RosPackage.CATKIN_PACKAGE: + sequence_CatkinPackage(context, (CatkinPackage) semanticObject); + return; + case RosPackage.EXTERNAL_DEPENDENCY: + sequence_ExternalDependency(context, (ExternalDependency) semanticObject); + return; + case RosPackage.NODE: + sequence_Node(context, (Node) semanticObject); + return; + case RosPackage.PACKAGE_DEPENDENCY: + sequence_PackageDependency(context, (PackageDependency) semanticObject); + return; + case RosPackage.PARAMETER: + sequence_Parameter(context, (ros.Parameter) semanticObject); + return; + case RosPackage.PUBLISHER: + sequence_Publisher(context, (Publisher) semanticObject); + return; + case RosPackage.SUBSCRIBER: + sequence_Subscriber(context, (Subscriber) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * Artifact returns Artifact + * + * Constraint: + * (name=RosNames node=Node?) + */ + protected void sequence_Artifact(ISerializationContext context, Artifact semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * CatkinPackage returns CatkinPackage + * + * Constraint: + * (name=RosNames fromGitRepo=EString? artifact+=Artifact* (dependency+=Dependency dependency+=Dependency*)?) + */ + protected void sequence_CatkinPackage(ISerializationContext context, CatkinPackage semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Dependency returns ExternalDependency + * ExternalDependency returns ExternalDependency + * + * Constraint: + * name=EString + */ + protected void sequence_ExternalDependency(ISerializationContext context, ExternalDependency semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.EXTERNAL_DEPENDENCY__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.EXTERNAL_DEPENDENCY__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getExternalDependencyAccess().getNameEStringParserRuleCall_2_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Node returns Node + * + * Constraint: + * (name=RosNames publisher+=Publisher* subscriber+=Subscriber* parameter+=Parameter*) + */ + protected void sequence_Node(ISerializationContext context, Node semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Dependency returns PackageDependency + * PackageDependency returns PackageDependency + * + * Constraint: + * package=[Package|EString] + */ + protected void sequence_PackageDependency(ISerializationContext context, PackageDependency semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.PACKAGE_DEPENDENCY__PACKAGE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.PACKAGE_DEPENDENCY__PACKAGE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getPackageDependencyAccess().getPackagePackageEStringParserRuleCall_0_1(), semanticObject.eGet(RosPackage.Literals.PACKAGE_DEPENDENCY__PACKAGE, false)); + feeder.finish(); + } + + + /** + * Contexts: + * Parameter returns Parameter + * + * Constraint: + * name=EString + */ + protected void sequence_Parameter(ISerializationContext context, ros.Parameter semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getParameterAccess().getNameEStringParserRuleCall_1_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Publisher returns Publisher + * + * Constraint: + * (name=EString message=[TopicSpec|EString]) + */ + protected void sequence_Publisher(ISerializationContext context, Publisher semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME)); + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.PUBLISHER__MESSAGE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.PUBLISHER__MESSAGE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getPublisherAccess().getNameEStringParserRuleCall_1_0(), semanticObject.getName()); + feeder.accept(grammarAccess.getPublisherAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1(), semanticObject.eGet(RosPackage.Literals.PUBLISHER__MESSAGE, false)); + feeder.finish(); + } + + + /** + * Contexts: + * Subscriber returns Subscriber + * + * Constraint: + * (name=EString message=[TopicSpec|EString]) + */ + protected void sequence_Subscriber(ISerializationContext context, Subscriber semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.NAMESPACED_ELEMENT__NAME)); + if (transientValues.isValueTransient(semanticObject, RosPackage.Literals.SUBSCRIBER__MESSAGE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RosPackage.Literals.SUBSCRIBER__MESSAGE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getSubscriberAccess().getNameEStringParserRuleCall_1_0(), semanticObject.getName()); + feeder.accept(grammarAccess.getSubscriberAccess().getMessageTopicSpecEStringParserRuleCall_5_0_1(), semanticObject.eGet(RosPackage.Literals.SUBSCRIBER__MESSAGE, false)); + feeder.finish(); + } + + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SyntacticSequencer.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SyntacticSequencer.java new file mode 100644 index 000000000..334bf1c10 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/serializer/Ros1SyntacticSequencer.java @@ -0,0 +1,131 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.serializer; + +import com.google.inject.Inject; +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess; +import java.util.List; +import org.eclipse.emf.ecore.EObject; +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 class Ros1SyntacticSequencer extends AbstractSyntacticSequencer { + + protected Ros1GrammarAccess grammarAccess; + protected AbstractElementAlias match_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_Node___ParametersKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q; + protected AbstractElementAlias match_Node___PublishersKeyword_3_0_BEGINTerminalRuleCall_3_1_ENDTerminalRuleCall_3_3__q; + protected AbstractElementAlias match_Node___SubscribersKeyword_4_0_BEGINTerminalRuleCall_4_1_ENDTerminalRuleCall_4_3__q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (Ros1GrammarAccess) access; + match_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getCatkinPackageAccess().getArtifactsKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getCatkinPackageAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getCatkinPackageAccess().getENDTerminalRuleCall_5_3())); + match_Node___ParametersKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getParametersKeyword_5_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_5_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_5_3())); + match_Node___PublishersKeyword_3_0_BEGINTerminalRuleCall_3_1_ENDTerminalRuleCall_3_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getPublishersKeyword_3_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_3_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_3_3())); + match_Node___SubscribersKeyword_4_0_BEGINTerminalRuleCall_4_1_ENDTerminalRuleCall_4_3__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getNodeAccess().getSubscribersKeyword_4_0()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getBEGINTerminalRuleCall_4_1()), new TokenAlias(false, false, grammarAccess.getNodeAccess().getENDTerminalRuleCall_4_3())); + } + + @Override + protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (ruleCall.getRule() == grammarAccess.getBEGINRule()) + return getBEGINToken(semanticObject, ruleCall, node); + else if (ruleCall.getRule() == grammarAccess.getENDRule()) + return getENDToken(semanticObject, ruleCall, node); + return ""; + } + + /** + * Synthetic terminal rule. The concrete syntax is to be specified by clients. + * Defaults to the empty string. + */ + protected String getBEGINToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } + + /** + * Synthetic terminal rule. The concrete syntax is to be specified by clients. + * Defaults to the empty string. + */ + protected String getENDToken(EObject semanticObject, RuleCall ruleCall, INode 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_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___ParametersKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q.equals(syntax)) + emit_Node___ParametersKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___PublishersKeyword_3_0_BEGINTerminalRuleCall_3_1_ENDTerminalRuleCall_3_3__q.equals(syntax)) + emit_Node___PublishersKeyword_3_0_BEGINTerminalRuleCall_3_1_ENDTerminalRuleCall_3_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_Node___SubscribersKeyword_4_0_BEGINTerminalRuleCall_4_1_ENDTerminalRuleCall_4_3__q.equals(syntax)) + emit_Node___SubscribersKeyword_4_0_BEGINTerminalRuleCall_4_1_ENDTerminalRuleCall_4_3__q(semanticObject, getLastNavigableState(), syntaxNodes); + else acceptNodes(getLastNavigableState(), syntaxNodes); + } + } + + /** + * Ambiguous syntax: + * ('artifacts:' BEGIN END)? + * + * This ambiguous syntax occurs at: + * fromGitRepo=EString (ambiguity) 'dependencies:' '[' dependency+=Dependency + * fromGitRepo=EString (ambiguity) END (rule end) + * name=RosNames ':' BEGIN (ambiguity) 'dependencies:' '[' dependency+=Dependency + * name=RosNames ':' BEGIN (ambiguity) END (rule end) + */ + protected void emit_CatkinPackage___ArtifactsKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('parameters:' BEGIN END)? + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN ('publishers:' BEGIN END)? ('subscribers:' BEGIN END)? (ambiguity) END (rule end) + * publisher+=Publisher END ('subscribers:' BEGIN END)? (ambiguity) END (rule end) + * subscriber+=Subscriber END (ambiguity) END (rule end) + */ + protected void emit_Node___ParametersKeyword_5_0_BEGINTerminalRuleCall_5_1_ENDTerminalRuleCall_5_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('publishers:' BEGIN END)? + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN (ambiguity) 'subscribers:' BEGIN subscriber+=Subscriber + * name=RosNames BEGIN (ambiguity) ('subscribers:' BEGIN END)? 'parameters:' BEGIN parameter+=Parameter + * name=RosNames BEGIN (ambiguity) ('subscribers:' BEGIN END)? ('parameters:' BEGIN END)? END (rule end) + */ + protected void emit_Node___PublishersKeyword_3_0_BEGINTerminalRuleCall_3_1_ENDTerminalRuleCall_3_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('subscribers:' BEGIN END)? + * + * This ambiguous syntax occurs at: + * name=RosNames BEGIN ('publishers:' BEGIN END)? (ambiguity) 'parameters:' BEGIN parameter+=Parameter + * name=RosNames BEGIN ('publishers:' BEGIN END)? (ambiguity) ('parameters:' BEGIN END)? END (rule end) + * publisher+=Publisher END (ambiguity) 'parameters:' BEGIN parameter+=Parameter + * publisher+=Publisher END (ambiguity) ('parameters:' BEGIN END)? END (rule end) + */ + protected void emit_Node___SubscribersKeyword_4_0_BEGINTerminalRuleCall_4_1_ENDTerminalRuleCall_4_3__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/services/Ros1GrammarAccess.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/services/Ros1GrammarAccess.java new file mode 100644 index 000000000..d0fe67bf9 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/services/Ros1GrammarAccess.java @@ -0,0 +1,980 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import java.util.List; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Alternatives; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.CrossReference; +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.common.services.TerminalsGrammarAccess; +import org.eclipse.xtext.service.AbstractElementFinder; +import org.eclipse.xtext.service.GrammarProvider; + +@Singleton +public class Ros1GrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { + + public class CatkinPackageElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.CatkinPackage"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cCatkinPackageAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameRosNamesParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Group cGroup_4 = (Group)cGroup.eContents().get(4); + private final Keyword cFromGitRepoKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); + private final Assignment cFromGitRepoAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); + private final RuleCall cFromGitRepoEStringParserRuleCall_4_1_0 = (RuleCall)cFromGitRepoAssignment_4_1.eContents().get(0); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final Keyword cArtifactsKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_5_1 = (RuleCall)cGroup_5.eContents().get(1); + private final Assignment cArtifactAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); + private final RuleCall cArtifactArtifactParserRuleCall_5_2_0 = (RuleCall)cArtifactAssignment_5_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5_3 = (RuleCall)cGroup_5.eContents().get(3); + private final Group cGroup_6 = (Group)cGroup.eContents().get(6); + private final Keyword cDependenciesKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0); + private final Keyword cLeftSquareBracketKeyword_6_1 = (Keyword)cGroup_6.eContents().get(1); + private final Assignment cDependencyAssignment_6_2 = (Assignment)cGroup_6.eContents().get(2); + private final RuleCall cDependencyDependencyParserRuleCall_6_2_0 = (RuleCall)cDependencyAssignment_6_2.eContents().get(0); + private final Group cGroup_6_3 = (Group)cGroup_6.eContents().get(3); + private final Keyword cCommaKeyword_6_3_0 = (Keyword)cGroup_6_3.eContents().get(0); + private final Assignment cDependencyAssignment_6_3_1 = (Assignment)cGroup_6_3.eContents().get(1); + private final RuleCall cDependencyDependencyParserRuleCall_6_3_1_0 = (RuleCall)cDependencyAssignment_6_3_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_6_4 = (Keyword)cGroup_6.eContents().get(4); + private final RuleCall cENDTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); + + //CatkinPackage returns ros::CatkinPackage: + // {ros::CatkinPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + @Override public ParserRule getRule() { return rule; } + + //{ros::CatkinPackage} + //name=RosNames':' + //BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + //END + public Group getGroup() { return cGroup; } + + //{ros::CatkinPackage} + public Action getCatkinPackageAction_0() { return cCatkinPackageAction_0; } + + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //('fromGitRepo:' fromGitRepo=EString)? + public Group getGroup_4() { return cGroup_4; } + + //'fromGitRepo:' + public Keyword getFromGitRepoKeyword_4_0() { return cFromGitRepoKeyword_4_0; } + + //fromGitRepo=EString + public Assignment getFromGitRepoAssignment_4_1() { return cFromGitRepoAssignment_4_1; } + + //EString + public RuleCall getFromGitRepoEStringParserRuleCall_4_1_0() { return cFromGitRepoEStringParserRuleCall_4_1_0; } + + //('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + //)? + public Group getGroup_5() { return cGroup_5; } + + //'artifacts:' + public Keyword getArtifactsKeyword_5_0() { return cArtifactsKeyword_5_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_1() { return cBEGINTerminalRuleCall_5_1; } + + //artifact+=Artifact* + public Assignment getArtifactAssignment_5_2() { return cArtifactAssignment_5_2; } + + //Artifact + public RuleCall getArtifactArtifactParserRuleCall_5_2_0() { return cArtifactArtifactParserRuleCall_5_2_0; } + + //END + public RuleCall getENDTerminalRuleCall_5_3() { return cENDTerminalRuleCall_5_3; } + + //('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + public Group getGroup_6() { return cGroup_6; } + + //'dependencies:' + public Keyword getDependenciesKeyword_6_0() { return cDependenciesKeyword_6_0; } + + //'[' + public Keyword getLeftSquareBracketKeyword_6_1() { return cLeftSquareBracketKeyword_6_1; } + + //dependency+=Dependency + public Assignment getDependencyAssignment_6_2() { return cDependencyAssignment_6_2; } + + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_2_0() { return cDependencyDependencyParserRuleCall_6_2_0; } + + //(',' dependency+=Dependency)* + public Group getGroup_6_3() { return cGroup_6_3; } + + //',' + public Keyword getCommaKeyword_6_3_0() { return cCommaKeyword_6_3_0; } + + //dependency+=Dependency + public Assignment getDependencyAssignment_6_3_1() { return cDependencyAssignment_6_3_1; } + + //Dependency + public RuleCall getDependencyDependencyParserRuleCall_6_3_1_0() { return cDependencyDependencyParserRuleCall_6_3_1_0; } + + //']' + public Keyword getRightSquareBracketKeyword_6_4() { return cRightSquareBracketKeyword_6_4; } + + //END + public RuleCall getENDTerminalRuleCall_7() { return cENDTerminalRuleCall_7; } + } + public class ArtifactElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Artifact"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cArtifactAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameRosNamesParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Assignment cNodeAssignment_4 = (Assignment)cGroup.eContents().get(4); + private final RuleCall cNodeNodeParserRuleCall_4_0 = (RuleCall)cNodeAssignment_4.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5 = (RuleCall)cGroup.eContents().get(5); + + //Artifact returns ros::Artifact: + // {ros::Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ros::Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END + public Group getGroup() { return cGroup; } + + //{ros::Artifact} + public Action getArtifactAction_0() { return cArtifactAction_0; } + + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //(node=Node)? + public Assignment getNodeAssignment_4() { return cNodeAssignment_4; } + + //Node + public RuleCall getNodeNodeParserRuleCall_4_0() { return cNodeNodeParserRuleCall_4_0; } + + //END + public RuleCall getENDTerminalRuleCall_5() { return cENDTerminalRuleCall_5; } + } + public class NodeElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Node"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cNodeKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameRosNamesParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cPublishersKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_3_1 = (RuleCall)cGroup_3.eContents().get(1); + private final Assignment cPublisherAssignment_3_2 = (Assignment)cGroup_3.eContents().get(2); + private final RuleCall cPublisherPublisherParserRuleCall_3_2_0 = (RuleCall)cPublisherAssignment_3_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_3_3 = (RuleCall)cGroup_3.eContents().get(3); + private final Group cGroup_4 = (Group)cGroup.eContents().get(4); + private final Keyword cSubscribersKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_4_1 = (RuleCall)cGroup_4.eContents().get(1); + private final Assignment cSubscriberAssignment_4_2 = (Assignment)cGroup_4.eContents().get(2); + private final RuleCall cSubscriberSubscriberParserRuleCall_4_2_0 = (RuleCall)cSubscriberAssignment_4_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_4_3 = (RuleCall)cGroup_4.eContents().get(3); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final Keyword cParametersKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); + private final RuleCall cBEGINTerminalRuleCall_5_1 = (RuleCall)cGroup_5.eContents().get(1); + private final Assignment cParameterAssignment_5_2 = (Assignment)cGroup_5.eContents().get(2); + private final RuleCall cParameterParameterParserRuleCall_5_2_0 = (RuleCall)cParameterAssignment_5_2.eContents().get(0); + private final RuleCall cENDTerminalRuleCall_5_3 = (RuleCall)cGroup_5.eContents().get(3); + private final RuleCall cENDTerminalRuleCall_6 = (RuleCall)cGroup.eContents().get(6); + + //Node returns ros::Node: + // 'node:' name=RosNames + // BEGIN + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )? + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )? + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // )? + // END; + @Override public ParserRule getRule() { return rule; } + + //'node:' name=RosNames + //BEGIN + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )? + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )? + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // )? + //END + public Group getGroup() { return cGroup; } + + //'node:' + public Keyword getNodeKeyword_0() { return cNodeKeyword_0; } + + //name=RosNames + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //RosNames + public RuleCall getNameRosNamesParserRuleCall_1_0() { return cNameRosNamesParserRuleCall_1_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_2() { return cBEGINTerminalRuleCall_2; } + + //('publishers:' + // BEGIN + // publisher+=Publisher* + // END + //)? + public Group getGroup_3() { return cGroup_3; } + + //'publishers:' + public Keyword getPublishersKeyword_3_0() { return cPublishersKeyword_3_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3_1() { return cBEGINTerminalRuleCall_3_1; } + + //publisher+=Publisher* + public Assignment getPublisherAssignment_3_2() { return cPublisherAssignment_3_2; } + + //Publisher + public RuleCall getPublisherPublisherParserRuleCall_3_2_0() { return cPublisherPublisherParserRuleCall_3_2_0; } + + //END + public RuleCall getENDTerminalRuleCall_3_3() { return cENDTerminalRuleCall_3_3; } + + //('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + //)? + public Group getGroup_4() { return cGroup_4; } + + //'subscribers:' + public Keyword getSubscribersKeyword_4_0() { return cSubscribersKeyword_4_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_4_1() { return cBEGINTerminalRuleCall_4_1; } + + //subscriber+=Subscriber* + public Assignment getSubscriberAssignment_4_2() { return cSubscriberAssignment_4_2; } + + //Subscriber + public RuleCall getSubscriberSubscriberParserRuleCall_4_2_0() { return cSubscriberSubscriberParserRuleCall_4_2_0; } + + //END + public RuleCall getENDTerminalRuleCall_4_3() { return cENDTerminalRuleCall_4_3; } + + //('parameters:' + // BEGIN + // parameter+=Parameter* + // END + //)? + public Group getGroup_5() { return cGroup_5; } + + //'parameters:' + public Keyword getParametersKeyword_5_0() { return cParametersKeyword_5_0; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_5_1() { return cBEGINTerminalRuleCall_5_1; } + + //parameter+=Parameter* + public Assignment getParameterAssignment_5_2() { return cParameterAssignment_5_2; } + + //Parameter + public RuleCall getParameterParameterParserRuleCall_5_2_0() { return cParameterParameterParserRuleCall_5_2_0; } + + //END + public RuleCall getENDTerminalRuleCall_5_3() { return cENDTerminalRuleCall_5_3; } + + //END + public RuleCall getENDTerminalRuleCall_6() { return cENDTerminalRuleCall_6; } + } + public class PublisherElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Publisher"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cPublisherAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameEStringParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Keyword cTypeKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cMessageAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cMessageTopicSpecCrossReference_5_0 = (CrossReference)cMessageAssignment_5.eContents().get(0); + private final RuleCall cMessageTopicSpecEStringParserRuleCall_5_0_1 = (RuleCall)cMessageTopicSpecCrossReference_5_0.eContents().get(1); + private final RuleCall cENDTerminalRuleCall_6 = (RuleCall)cGroup.eContents().get(6); + + //Publisher returns ros::Publisher: + // {ros::Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + // ; + @Override public ParserRule getRule() { return rule; } + + //{ros::Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + public Group getGroup() { return cGroup; } + + //{ros::Publisher} + public Action getPublisherAction_0() { return cPublisherAction_0; } + + //name=EString + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //EString + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } + + //message=[ros::TopicSpec|EString] + public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + + //[ros::TopicSpec|EString] + public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } + + //EString + public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } + + //END + public RuleCall getENDTerminalRuleCall_6() { return cENDTerminalRuleCall_6; } + } + public class SubscriberElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Subscriber"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cSubscriberAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameEStringParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final Keyword cTypeKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cMessageAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final CrossReference cMessageTopicSpecCrossReference_5_0 = (CrossReference)cMessageAssignment_5.eContents().get(0); + private final RuleCall cMessageTopicSpecEStringParserRuleCall_5_0_1 = (RuleCall)cMessageTopicSpecCrossReference_5_0.eContents().get(1); + private final RuleCall cENDTerminalRuleCall_6 = (RuleCall)cGroup.eContents().get(6); + + //Subscriber returns ros::Subscriber: + // {ros::Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + //; + @Override public ParserRule getRule() { return rule; } + + //{ros::Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + public Group getGroup() { return cGroup; } + + //{ros::Subscriber} + public Action getSubscriberAction_0() { return cSubscriberAction_0; } + + //name=EString + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //EString + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + //'type:' + public Keyword getTypeKeyword_4() { return cTypeKeyword_4; } + + //message=[ros::TopicSpec|EString] + public Assignment getMessageAssignment_5() { return cMessageAssignment_5; } + + //[ros::TopicSpec|EString] + public CrossReference getMessageTopicSpecCrossReference_5_0() { return cMessageTopicSpecCrossReference_5_0; } + + //EString + public RuleCall getMessageTopicSpecEStringParserRuleCall_5_0_1() { return cMessageTopicSpecEStringParserRuleCall_5_0_1; } + + //END + public RuleCall getENDTerminalRuleCall_6() { return cENDTerminalRuleCall_6; } + } + public class ParameterElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Parameter"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cParameterAction_0 = (Action)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameEStringParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cBEGINTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + private final RuleCall cENDTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); + private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); + + //Parameter returns ros::Parameter: + // {ros::Parameter} + // name=EString':' + // BEGIN + // //'type' type=ParameterType + // END + // '}'; + @Override public ParserRule getRule() { return rule; } + + //{ros::Parameter} + // name=EString':' + // BEGIN + // //'type' type=ParameterType + // END + //'}' + public Group getGroup() { return cGroup; } + + //{ros::Parameter} + public Action getParameterAction_0() { return cParameterAction_0; } + + //name=EString + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //EString + public RuleCall getNameEStringParserRuleCall_1_0() { return cNameEStringParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //BEGIN + public RuleCall getBEGINTerminalRuleCall_3() { return cBEGINTerminalRuleCall_3; } + + ////'type' type=ParameterType + //END + public RuleCall getENDTerminalRuleCall_4() { return cENDTerminalRuleCall_4; } + + //'}' + public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } + } + public class DependencyElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.Dependency"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cPackageDependencyParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cExternalDependencyParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //// + //Dependency returns ros::Dependency: + // PackageDependency | ExternalDependency; + @Override public ParserRule getRule() { return rule; } + + //PackageDependency | ExternalDependency + public Alternatives getAlternatives() { return cAlternatives; } + + //PackageDependency + public RuleCall getPackageDependencyParserRuleCall_0() { return cPackageDependencyParserRuleCall_0; } + + //ExternalDependency + public RuleCall getExternalDependencyParserRuleCall_1() { return cExternalDependencyParserRuleCall_1; } + } + public class PackageDependencyElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.PackageDependency"); + private final Assignment cPackageAssignment = (Assignment)rule.eContents().get(1); + private final CrossReference cPackagePackageCrossReference_0 = (CrossReference)cPackageAssignment.eContents().get(0); + private final RuleCall cPackagePackageEStringParserRuleCall_0_1 = (RuleCall)cPackagePackageCrossReference_0.eContents().get(1); + + //PackageDependency returns ros::PackageDependency: + // package=[ros::Package|EString] + //; + @Override public ParserRule getRule() { return rule; } + + //package=[ros::Package|EString] + public Assignment getPackageAssignment() { return cPackageAssignment; } + + //[ros::Package|EString] + public CrossReference getPackagePackageCrossReference_0() { return cPackagePackageCrossReference_0; } + + //EString + public RuleCall getPackagePackageEStringParserRuleCall_0_1() { return cPackagePackageEStringParserRuleCall_0_1; } + } + public class ExternalDependencyElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.ExternalDependency"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cExternalDependencyAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cExternalDependencyKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cNameEStringParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); + + //ExternalDependency returns ros::ExternalDependency: + // {ros::ExternalDependency} + // 'ExternalDependency' + // name=EString; + @Override public ParserRule getRule() { return rule; } + + //{ros::ExternalDependency} + //'ExternalDependency' + //name=EString + public Group getGroup() { return cGroup; } + + //{ros::ExternalDependency} + public Action getExternalDependencyAction_0() { return cExternalDependencyAction_0; } + + //'ExternalDependency' + public Keyword getExternalDependencyKeyword_1() { return cExternalDependencyKeyword_1; } + + //name=EString + public Assignment getNameAssignment_2() { return cNameAssignment_2; } + + //EString + public RuleCall getNameEStringParserRuleCall_2_0() { return cNameEStringParserRuleCall_2_0; } + } + public class RosNamesElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.RosNames"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cROS_CONVENTION_ATerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final Keyword cNodeKeyword_2 = (Keyword)cAlternatives.eContents().get(2); + + //RosNames returns ecore::EString: + // ROS_CONVENTION_A | ID | 'node' + //; + @Override public ParserRule getRule() { return rule; } + + //ROS_CONVENTION_A | ID | 'node' + public Alternatives getAlternatives() { return cAlternatives; } + + //ROS_CONVENTION_A + public RuleCall getROS_CONVENTION_ATerminalRuleCall_0() { return cROS_CONVENTION_ATerminalRuleCall_0; } + + //ID + public RuleCall getIDTerminalRuleCall_1() { return cIDTerminalRuleCall_1; } + + //'node' + public Keyword getNodeKeyword_2() { return cNodeKeyword_2; } + } + public class EStringElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.EString"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cSTRINGTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //EString returns ecore::EString: + // STRING | ID; + @Override public ParserRule getRule() { return rule; } + + //STRING | ID + public Alternatives getAlternatives() { return cAlternatives; } + + //STRING + public RuleCall getSTRINGTerminalRuleCall_0() { return cSTRINGTerminalRuleCall_0; } + + //ID + public RuleCall getIDTerminalRuleCall_1() { return cIDTerminalRuleCall_1; } + } + public class RosParamNamesElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.RosParamNames"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cROS_CONVENTION_PARAMTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //RosParamNames returns ecore::EString: + // ROS_CONVENTION_PARAM | ID + //; + @Override public ParserRule getRule() { return rule; } + + //ROS_CONVENTION_PARAM | ID + public Alternatives getAlternatives() { return cAlternatives; } + + //ROS_CONVENTION_PARAM + public RuleCall getROS_CONVENTION_PARAMTerminalRuleCall_0() { return cROS_CONVENTION_PARAMTerminalRuleCall_0; } + + //ID + public RuleCall getIDTerminalRuleCall_1() { return cIDTerminalRuleCall_1; } + } + + + private final CatkinPackageElements pCatkinPackage; + private final ArtifactElements pArtifact; + private final NodeElements pNode; + private final PublisherElements pPublisher; + private final SubscriberElements pSubscriber; + private final ParameterElements pParameter; + private final TerminalRule tBEGIN; + private final TerminalRule tEND; + private final TerminalRule tSL_COMMENT; + private final DependencyElements pDependency; + private final PackageDependencyElements pPackageDependency; + private final ExternalDependencyElements pExternalDependency; + private final RosNamesElements pRosNames; + private final EStringElements pEString; + private final RosParamNamesElements pRosParamNames; + private final TerminalRule tROS_CONVENTION_A; + private final TerminalRule tROS_CONVENTION_PARAM; + + private final Grammar grammar; + + private final TerminalsGrammarAccess gaTerminals; + + @Inject + public Ros1GrammarAccess(GrammarProvider grammarProvider, + TerminalsGrammarAccess gaTerminals) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaTerminals = gaTerminals; + this.pCatkinPackage = new CatkinPackageElements(); + this.pArtifact = new ArtifactElements(); + this.pNode = new NodeElements(); + this.pPublisher = new PublisherElements(); + this.pSubscriber = new SubscriberElements(); + this.pParameter = new ParameterElements(); + this.tBEGIN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.BEGIN"); + this.tEND = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.END"); + this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.SL_COMMENT"); + this.pDependency = new DependencyElements(); + this.pPackageDependency = new PackageDependencyElements(); + this.pExternalDependency = new ExternalDependencyElements(); + this.pRosNames = new RosNamesElements(); + this.pEString = new EStringElements(); + this.pRosParamNames = new RosParamNamesElements(); + this.tROS_CONVENTION_A = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.ROS_CONVENTION_A"); + this.tROS_CONVENTION_PARAM = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.fraunhofer.ipa.ros1.Ros1.ROS_CONVENTION_PARAM"); + } + + protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { + Grammar grammar = grammarProvider.getGrammar(this); + while (grammar != null) { + if ("de.fraunhofer.ipa.ros1.Ros1".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 TerminalsGrammarAccess getTerminalsGrammarAccess() { + return gaTerminals; + } + + + //CatkinPackage returns ros::CatkinPackage: + // {ros::CatkinPackage} + // name=RosNames':' + // BEGIN + // ('fromGitRepo:' fromGitRepo=EString)? + // ('artifacts:' + // BEGIN + // artifact+=Artifact* + // END + // )? + // ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + // END; + public CatkinPackageElements getCatkinPackageAccess() { + return pCatkinPackage; + } + + public ParserRule getCatkinPackageRule() { + return getCatkinPackageAccess().getRule(); + } + + //Artifact returns ros::Artifact: + // {ros::Artifact} + // name=RosNames':' + // BEGIN + // (node=Node)? + // END + // ; + public ArtifactElements getArtifactAccess() { + return pArtifact; + } + + public ParserRule getArtifactRule() { + return getArtifactAccess().getRule(); + } + + //Node returns ros::Node: + // 'node:' name=RosNames + // BEGIN + // ('publishers:' + // BEGIN + // publisher+=Publisher* + // END + // )? + // ('subscribers:' + // BEGIN + // subscriber+=Subscriber* + // END + // )? + // ('parameters:' + // BEGIN + // parameter+=Parameter* + // END + // )? + // END; + public NodeElements getNodeAccess() { + return pNode; + } + + public ParserRule getNodeRule() { + return getNodeAccess().getRule(); + } + + //Publisher returns ros::Publisher: + // {ros::Publisher} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + // ; + public PublisherElements getPublisherAccess() { + return pPublisher; + } + + public ParserRule getPublisherRule() { + return getPublisherAccess().getRule(); + } + + //Subscriber returns ros::Subscriber: + // {ros::Subscriber} + // name=EString':' + // BEGIN + // 'type:' message=[ros::TopicSpec|EString] + // END + //; + public SubscriberElements getSubscriberAccess() { + return pSubscriber; + } + + public ParserRule getSubscriberRule() { + return getSubscriberAccess().getRule(); + } + + //Parameter returns ros::Parameter: + // {ros::Parameter} + // name=EString':' + // BEGIN + // //'type' type=ParameterType + // END + // '}'; + public ParameterElements getParameterAccess() { + return pParameter; + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //// YAML format + //terminal BEGIN: 'synthetic:BEGIN'; + public TerminalRule getBEGINRule() { + return tBEGIN; + } + + //terminal END: 'synthetic:END'; + public TerminalRule getENDRule() { + return tEND; + } + + //@Override + //terminal SL_COMMENT: '#' !('\n'|'\r')*; + public TerminalRule getSL_COMMENTRule() { + return tSL_COMMENT; + } + + //// + //Dependency returns ros::Dependency: + // PackageDependency | ExternalDependency; + public DependencyElements getDependencyAccess() { + return pDependency; + } + + public ParserRule getDependencyRule() { + return getDependencyAccess().getRule(); + } + + //PackageDependency returns ros::PackageDependency: + // package=[ros::Package|EString] + //; + public PackageDependencyElements getPackageDependencyAccess() { + return pPackageDependency; + } + + public ParserRule getPackageDependencyRule() { + return getPackageDependencyAccess().getRule(); + } + + //ExternalDependency returns ros::ExternalDependency: + // {ros::ExternalDependency} + // 'ExternalDependency' + // name=EString; + public ExternalDependencyElements getExternalDependencyAccess() { + return pExternalDependency; + } + + public ParserRule getExternalDependencyRule() { + return getExternalDependencyAccess().getRule(); + } + + //RosNames returns ecore::EString: + // ROS_CONVENTION_A | ID | 'node' + //; + public RosNamesElements getRosNamesAccess() { + return pRosNames; + } + + public ParserRule getRosNamesRule() { + return getRosNamesAccess().getRule(); + } + + //EString returns ecore::EString: + // STRING | ID; + public EStringElements getEStringAccess() { + return pEString; + } + + public ParserRule getEStringRule() { + return getEStringAccess().getRule(); + } + + //RosParamNames returns ecore::EString: + // ROS_CONVENTION_PARAM | ID + //; + public RosParamNamesElements getRosParamNamesAccess() { + return pRosParamNames; + } + + public ParserRule getRosParamNamesRule() { + return getRosParamNamesAccess().getRule(); + } + + //terminal ROS_CONVENTION_A: + // ( ('/' ID ) | ( ID '/' ) )* ; + public TerminalRule getROS_CONVENTION_ARule() { + return tROS_CONVENTION_A; + } + + //terminal ROS_CONVENTION_PARAM: + // ( ('/' STRING ) | ( STRING '/' ) | ('~' STRING ) )* ; + public TerminalRule getROS_CONVENTION_PARAMRule() { + return tROS_CONVENTION_PARAM; + } + + //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + public TerminalRule getIDRule() { + return gaTerminals.getIDRule(); + } + + //terminal INT returns ecore::EInt: ('0'..'9')+; + public TerminalRule getINTRule() { + return gaTerminals.getINTRule(); + } + + //terminal STRING: + // '"' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'"') )* '"' | + // "'" ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|"'") )* "'" + // ; + public TerminalRule getSTRINGRule() { + return gaTerminals.getSTRINGRule(); + } + + //terminal ML_COMMENT : '/*' -> '*/'; + public TerminalRule getML_COMMENTRule() { + return gaTerminals.getML_COMMENTRule(); + } + + //terminal WS : (' '|'\t'|'\r'|'\n')+; + public TerminalRule getWSRule() { + return gaTerminals.getWSRule(); + } + + //terminal ANY_OTHER: .; + public TerminalRule getANY_OTHERRule() { + return gaTerminals.getANY_OTHERRule(); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/AbstractRos1Validator.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/AbstractRos1Validator.java new file mode 100644 index 000000000..e58835915 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/AbstractRos1Validator.java @@ -0,0 +1,19 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.validation; + +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.xtext.validation.AbstractDeclarativeValidator; + +public abstract class AbstractRos1Validator extends AbstractDeclarativeValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.ipa.fraunhofer.de/ros")); + return result; + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ConfigurableIssueCodesProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ConfigurableIssueCodesProvider.java new file mode 100644 index 000000000..d9b4f3631 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src-gen/de/fraunhofer/ipa/ros1/validation/Ros1ConfigurableIssueCodesProvider.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.validation; + +import org.eclipse.xtext.preferences.PreferenceKey; +import org.eclipse.xtext.util.IAcceptor; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; +import org.eclipse.xtext.validation.SeverityConverter; + +@SuppressWarnings("restriction") +public class Ros1ConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider { + protected static final String ISSUE_CODE_PREFIX = "de.fraunhofer.ipa.ros1."; + + public static final String DEPRECATED_MODEL_PART = ISSUE_CODE_PREFIX + "deprecatedModelPart"; + + @Override + protected void initialize(IAcceptor acceptor) { + super.initialize(acceptor); + acceptor.accept(create(DEPRECATED_MODEL_PART, SeverityConverter.SEVERITY_WARNING)); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 new file mode 100644 index 000000000..74b46fd23 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/GenerateRos1.mwe2 @@ -0,0 +1,61 @@ +module de.fraunhofer.ipa.ros1.GenerateRos1 + +import org.eclipse.xtext.xtext.generator.* +import org.eclipse.xtext.xtext.generator.model.project.* + +var rootPath = ".." + +Workflow { + + component = XtextGenerator { + configuration = { + project = StandardProjectConfig { + baseName = "de.fraunhofer.ipa.ros1.xtext" + rootPath = rootPath + runtimeTest = { + enabled = false + } + eclipsePlugin = { + enabled = true + } + eclipsePluginTest = { + enabled = false + } + createEclipseMetaData = true + } + code = { + encoding = "UTF-8" + lineDelimiter = "\n" + fileHeader = "/*\n * generated by Xtext \${version}\n */" + preferXtendStubs = false + } + } + language = StandardLanguage { + name = "de.fraunhofer.ipa.ros1.Ros1" + fileExtensions = "ros1" + referencedResource = "platform:/resource/de.fraunhofer.ipa.ros/model/ros.genmodel" + + fragment = ecore2xtext.Ecore2XtextValueConverterServiceFragment2 auto-inject {} + + formatter = { + generateStub = false + generateXtendStub = true + } + + serializer = { + generateStub = false + } + validator = { + // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" + // Generates checks for @Deprecated grammar annotations, an IssueProvider and a corresponding PropertyPage + generateDeprecationValidation = true + } + generator = { + generateXtendStub = true + } + junitSupport = { + junitVersion = "5" + } + } + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1.xtext b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1.xtext new file mode 100644 index 000000000..fed213e29 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1.xtext @@ -0,0 +1,112 @@ +// automatically generated by Xtext +grammar de.fraunhofer.ipa.ros1.Ros1 with org.eclipse.xtext.common.Terminals + +import "http://www.ipa.fraunhofer.de/primitives" +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.ipa.fraunhofer.de/ros" as ros + +CatkinPackage returns ros::CatkinPackage: + {ros::CatkinPackage} + name=RosNames':' + BEGIN + ('fromGitRepo:' fromGitRepo=EString)? + ('artifacts:' + BEGIN + artifact+=Artifact* + END + )? + ('dependencies:' '[' dependency+=Dependency (',' dependency+=Dependency)* ']' )? + END; + + +Artifact returns ros::Artifact: + {ros::Artifact} + + name=RosNames':' + BEGIN + (node=Node)? + END + ; + +Node returns ros::Node: + 'node:' name=RosNames + BEGIN + ('publishers:' + BEGIN + publisher+=Publisher* + END + )? + ('subscribers:' + BEGIN + subscriber+=Subscriber* + END + )? + ('parameters:' + BEGIN + parameter+=Parameter* + END + )? + END; + +Publisher returns ros::Publisher: + {ros::Publisher} + name=EString':' + BEGIN + 'type:' message=[ros::TopicSpec|EString] + END + ; + +Subscriber returns ros::Subscriber: + {ros::Subscriber} + name=EString':' + BEGIN + 'type:' message=[ros::TopicSpec|EString] + END +; + +Parameter returns ros::Parameter: + {ros::Parameter} + name=EString':' + BEGIN + //'type' type=ParameterType + END + '}'; + + +// YAML format +terminal BEGIN: 'synthetic:BEGIN'; +terminal END: 'synthetic:END'; + +@Override +terminal SL_COMMENT: '#' !('\n'|'\r')*; +// + + +Dependency returns ros::Dependency: + PackageDependency | ExternalDependency; + +PackageDependency returns ros::PackageDependency: + package=[ros::Package|EString] +; + +ExternalDependency returns ros::ExternalDependency: + {ros::ExternalDependency} + 'ExternalDependency' + name=EString; + +RosNames returns ecore::EString: + ROS_CONVENTION_A | ID | 'node' +; + +EString returns ecore::EString: + STRING | ID; + +RosParamNames returns ecore::EString: + ROS_CONVENTION_PARAM | ID +; + +terminal ROS_CONVENTION_A: + ( ('/' ID ) | ( ID '/' ) )* ; + +terminal ROS_CONVENTION_PARAM: + ( ('/' STRING ) | ( STRING '/' ) | ('~' STRING ) )* ; \ No newline at end of file diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1RuntimeModule.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1RuntimeModule.java new file mode 100644 index 000000000..c81245034 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1RuntimeModule.java @@ -0,0 +1,11 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1; + + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +public class Ros1RuntimeModule extends AbstractRos1RuntimeModule { +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1StandaloneSetup.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1StandaloneSetup.java new file mode 100644 index 000000000..f9fce5f63 --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/Ros1StandaloneSetup.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1; + + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +public class Ros1StandaloneSetup extends Ros1StandaloneSetupGenerated { + + public static void doSetup() { + new Ros1StandaloneSetup().createInjectorAndDoEMFRegistration(); + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/formatting2/Ros1Formatter.xtend b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/formatting2/Ros1Formatter.xtend new file mode 100644 index 000000000..e614fcbcd --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/formatting2/Ros1Formatter.xtend @@ -0,0 +1,32 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.formatting2 + +import com.google.inject.Inject +import de.fraunhofer.ipa.ros1.services.Ros1GrammarAccess +import org.eclipse.xtext.formatting2.AbstractFormatter2 +import org.eclipse.xtext.formatting2.IFormattableDocument +import ros.Artifact +import ros.CatkinPackage + +class Ros1Formatter extends AbstractFormatter2 { + + @Inject extension Ros1GrammarAccess + + def dispatch void format(CatkinPackage catkinPackage, extension IFormattableDocument document) { + // TODO: format HiddenRegions around keywords, attributes, cross references, etc. + for (artifact : catkinPackage.artifact) { + artifact.format + } + for (dependency : catkinPackage.dependency) { + dependency.format + } + } + + def dispatch void format(Artifact artifact, extension IFormattableDocument document) { + // TODO: format HiddenRegions around keywords, attributes, cross references, etc. + artifact.node.format + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/generator/Ros1Generator.xtend b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/generator/Ros1Generator.xtend new file mode 100644 index 000000000..ae7eb264a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/generator/Ros1Generator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.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 + */ +class Ros1Generator extends AbstractGenerator { + + override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { +// fsa.generateFile('greetings.txt', 'People to greet: ' + +// resource.allContents +// .filter(Greeting) +// .map[name] +// .join(', ')) + } +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/parser/antlr/Ros1TokenSource.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/parser/antlr/Ros1TokenSource.java new file mode 100644 index 000000000..63ce0c47e --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/parser/antlr/Ros1TokenSource.java @@ -0,0 +1,35 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.parser.antlr; + +import de.fraunhofer.ipa.ros1.parser.antlr.internal.InternalRos1Parser; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenSource; +import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource; + +public class Ros1TokenSource extends AbstractIndentationTokenSource { + + public Ros1TokenSource(TokenSource delegate) { + super(delegate); + } + + @Override + protected boolean shouldSplitTokenImpl(Token token) { + // TODO Review assumption + return token.getType() == InternalRos1Parser.RULE_WS; + } + + @Override + protected int getBeginTokenType() { + // TODO Review assumption + return InternalRos1Parser.RULE_BEGIN; + } + + @Override + protected int getEndTokenType() { + // TODO Review assumption + return InternalRos1Parser.RULE_END; + } + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/scoping/Ros1ScopeProvider.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/scoping/Ros1ScopeProvider.java new file mode 100644 index 000000000..294b01e1f --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/scoping/Ros1ScopeProvider.java @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.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 Ros1ScopeProvider extends AbstractRos1ScopeProvider { + +} diff --git a/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/validation/Ros1Validator.java b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/validation/Ros1Validator.java new file mode 100644 index 000000000..ee358110a --- /dev/null +++ b/plugins/de.fraunhofer.ipa.ros1.xtext/src/de/fraunhofer/ipa/ros1/validation/Ros1Validator.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package de.fraunhofer.ipa.ros1.validation; + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +public class Ros1Validator extends AbstractRos1Validator { + +// public static final String INVALID_NAME = "invalidName"; +// +// @Check +// public void checkGreetingStartsWithCapital(Greeting greeting) { +// if (!Character.isUpperCase(greeting.getName().charAt(0))) { +// warning("Name should start with a capital", +// Ros1Package.Literals.GREETING__NAME, +// INVALID_NAME); +// } +// } + +}